diff --git a/README.md b/README.md
index dbda35c1..545af500 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,7 @@ linear config               # setup your repo, it writes a config file
 
 linear issue list           # list unstarted issues assigned to you
 linear issue list -A        # list unstarted issues assigned to anyone
+linear issue search "login bug"  # search issues in your configured team
 linear issue start          # choose an issue to start, creates a branch
 linear issue start ABC-123  # start a specific issue
 linear issue view           # see current branch's issue as markdown
@@ -134,6 +135,8 @@ linear issue list      # list your issues in a table view (supports -s/--state a
 linear issue list --project "My Project" --milestone "Phase 1"  # filter by milestone
 linear issue list -w   # open issue list in web browser
 linear issue list -a   # open issue list in Linear.app
+linear issue search "login bug"         # search issues by text in your configured team
+linear issue search "oauth timeout" --team ENG --json  # structured search output for agents
 linear issue start     # create/switch to issue branch and mark as started
 linear issue create    # create a new issue (interactive prompts)
 linear issue create -t "title" -d "description"  # create with flags
diff --git a/skills/linear-cli/references/issue.md b/skills/linear-cli/references/issue.md
index 4915540a..e7e7b4b1 100644
--- a/skills/linear-cli/references/issue.md
+++ b/skills/linear-cli/references/issue.md
@@ -20,6 +20,7 @@ Commands:
 
   id                                      - Print the issue based on the current git branch    
   list                                    - List your issues                                   
+  search            <term>                - Search issues by text                              
   title             [issueId]             - Print the issue title                              
   start             [issueId]             - Start working on an issue                          
   view, v           [issueId]             - View issue details (default) or open in browser/app
@@ -92,6 +93,40 @@ Options:
   --no-pager                           - Disable automatic paging for long output
 ```
 
+### search
+
+> Search issues by text
+
+```
+Usage:   linear issue search <term>
+
+Description:
+
+  Search issues by text
+
+Options:
+
+  -h, --help                          - Show this help.                                                                                                                     
+  -w, --workspace     <slug>          - Target workspace (uses credentials)                                                                                                 
+  --team              <team>          - Team to search in                                                                                                                   
+  --all-teams                         - Search across all teams                                                                                                             
+  -s, --state         <state>         - Filter by issue state (can be repeated for multiple states)                    (Values: "triage", "backlog", "unstarted", "started",
+                                                                                                                       "completed", "canceled")                             
+  --assignee          <assignee>      - Filter by assignee (username)                                                                                                       
+  -U, --unassigned                    - Show only unassigned issues                                                                                                         
+  --project           <project>       - Filter by project name                                                                                                              
+  --project-label     <projectLabel>  - Filter by project label name (shows issues from all projects with this label)                                                       
+  -l, --label         <label>         - Filter by label name (can be repeated for multiple labels)                                                                          
+  --include-comments                  - Search associated comments too                                                                                                      
+  --include-archived                  - Include archived issues                                                                                                             
+  --created-after     <date>          - Filter issues created after this date (ISO 8601 or YYYY-MM-DD)                                                                      
+  --updated-after     <date>          - Filter issues updated after this date (ISO 8601 or YYYY-MM-DD)                                                                      
+  --order-by          <orderBy>       - Use the API's supported search ordering                                        (Values: "createdAt", "updatedAt")                   
+  --limit             <limit>         - Maximum number of results to fetch (default: 20, use 0 for unlimited)          (Default: 20)                                        
+  --no-pager                          - Disable automatic paging for long output                                                                                            
+  -j, --json                          - Output search results as JSON
+```
+
 ### title
 
 > Print the issue title
diff --git a/src/commands/issue/issue-search.ts b/src/commands/issue/issue-search.ts
new file mode 100644
index 00000000..a04a35ec
--- /dev/null
+++ b/src/commands/issue/issue-search.ts
@@ -0,0 +1,386 @@
+import { Command, EnumType } from "@cliffy/command"
+import { unicodeWidth } from "@std/cli"
+import { Spinner } from "@std/cli/unstable-spinner"
+import { rgb24 } from "@std/fmt/colors"
+import {
+  getPriorityDisplay,
+  getTimeAgo,
+  padDisplay,
+  truncateText,
+} from "../../utils/display.ts"
+import {
+  getProjectIdByName,
+  getProjectOptionsByName,
+  getTeamKey,
+  searchIssuesByTerm,
+  selectOption,
+} from "../../utils/linear.ts"
+import type { FetchedIssueSearchResult } from "../../utils/linear.ts"
+import { pipeToUserPager, shouldUsePager } from "../../utils/pager.ts"
+import { shouldShowSpinner } from "../../utils/hyperlink.ts"
+import { header, muted } from "../../utils/styling.ts"
+import {
+  handleError,
+  NotFoundError,
+  ValidationError,
+} from "../../utils/errors.ts"
+
+const StateType = new EnumType([
+  "triage",
+  "backlog",
+  "unstarted",
+  "started",
+  "completed",
+  "canceled",
+])
+
+const OrderByType = new EnumType(["createdAt", "updatedAt"])
+
+export const searchCommand = new Command()
+  .name("search")
+  .description("Search issues by text")
+  .arguments("<term:string>")
+  .type("state", StateType)
+  .type("orderBy", OrderByType)
+  .option("--team <team:string>", "Team to search in")
+  .option("--all-teams", "Search across all teams")
+  .option(
+    "-s, --state <state:state>",
+    "Filter by issue state (can be repeated for multiple states)",
+    {
+      collect: true,
+    },
+  )
+  .option("--assignee <assignee:string>", "Filter by assignee (username)")
+  .option("-U, --unassigned", "Show only unassigned issues")
+  .option("--project <project:string>", "Filter by project name")
+  .option(
+    "--project-label <projectLabel:string>",
+    "Filter by project label name (shows issues from all projects with this label)",
+  )
+  .option(
+    "-l, --label <label:string>",
+    "Filter by label name (can be repeated for multiple labels)",
+    { collect: true },
+  )
+  .option("--include-comments", "Search associated comments too")
+  .option("--include-archived", "Include archived issues")
+  .option(
+    "--created-after <date:string>",
+    "Filter issues created after this date (ISO 8601 or YYYY-MM-DD)",
+  )
+  .option(
+    "--updated-after <date:string>",
+    "Filter issues updated after this date (ISO 8601 or YYYY-MM-DD)",
+  )
+  .option(
+    "--order-by <orderBy:orderBy>",
+    "Use the API's supported search ordering",
+  )
+  .option(
+    "--limit <limit:number>",
+    "Maximum number of results to fetch (default: 20, use 0 for unlimited)",
+    { default: 20 },
+  )
+  .option("--no-pager", "Disable automatic paging for long output")
+  .option("-j, --json", "Output search results as JSON")
+  .action(async (options, term) => {
+    let spinner: Spinner | null = null
+
+    const {
+      team,
+      allTeams,
+      state,
+      assignee,
+      unassigned,
+      project,
+      projectLabel,
+      label,
+      includeComments,
+      includeArchived,
+      createdAfter,
+      updatedAfter,
+      orderBy,
+      limit,
+      pager,
+      json,
+    } = options
+
+    try {
+      const searchTerm = term.trim()
+      if (searchTerm.length === 0) {
+        throw new ValidationError("Search term cannot be empty", {
+          suggestion:
+            'Provide a term like `linear issue search "oauth timeout"`.',
+        })
+      }
+
+      if (team != null && allTeams) {
+        throw new ValidationError(
+          "Cannot use both --team and --all-teams flags",
+        )
+      }
+
+      if (limit < 0) {
+        throw new ValidationError("--limit must be 0 or greater")
+      }
+
+      if (assignee != null && unassigned) {
+        throw new ValidationError(
+          "Cannot specify both --assignee and --unassigned",
+        )
+      }
+
+      if (project != null && projectLabel != null) {
+        throw new ValidationError(
+          "Cannot use --project and --project-label together",
+          {
+            suggestion:
+              "Use --project to filter by a single project, or --project-label to filter by all projects with a given label.",
+          },
+        )
+      }
+
+      const teamKey = allTeams
+        ? undefined
+        : (team?.toUpperCase() || getTeamKey())
+      if (!allTeams && teamKey == null) {
+        throw new ValidationError(
+          "Could not determine team key from configuration or team flag",
+          {
+            suggestion:
+              "Use --team to specify a team key, or --all-teams to search across the whole workspace.",
+          },
+        )
+      }
+
+      let projectId: string | undefined
+      if (project != null) {
+        projectId = await getProjectIdByName(project)
+        if (projectId == null) {
+          const projectOptions = await getProjectOptionsByName(project)
+          if (Object.keys(projectOptions).length === 0) {
+            throw new NotFoundError("Project", project)
+          }
+          if (!Deno.stdin.isTerminal()) {
+            throw new ValidationError(
+              `Project "${project}" not found. Similar projects: ${
+                Object.values(projectOptions).join(", ")
+              }`,
+            )
+          }
+          projectId = await selectOption("Project", project, projectOptions)
+          if (projectId == null) {
+            throw new NotFoundError("Project", project)
+          }
+        }
+      }
+
+      const stateArray = Array.isArray(state)
+        ? state.flat()
+        : (state != null ? [state] : undefined)
+      const labelNames = Array.isArray(label) && label.length > 0
+        ? label.flat()
+        : undefined
+
+      spinner = shouldShowSpinner() && !json ? new Spinner() : null
+      spinner?.start()
+
+      const result = await searchIssuesByTerm(searchTerm, {
+        teamKey,
+        state: stateArray,
+        assignee,
+        unassigned,
+        limit,
+        projectId,
+        projectLabel,
+        labelNames,
+        createdAfter,
+        updatedAfter,
+        includeComments,
+        includeArchived,
+        orderBy,
+      })
+
+      spinner?.stop()
+
+      if (json) {
+        console.log(JSON.stringify(result, null, 2))
+        return
+      }
+
+      if (result.nodes.length === 0) {
+        console.log("No issues found.")
+        return
+      }
+
+      const outputLines = formatIssuesForDisplay(
+        result.nodes,
+        allTeams === true,
+        assignee == null && !unassigned,
+      )
+      const usePager = pager !== false
+
+      if (shouldUsePager(outputLines, usePager)) {
+        await pipeToUserPager(outputLines.join("\n"))
+      } else {
+        outputLines.forEach((line) => console.log(line))
+      }
+    } catch (error) {
+      spinner?.stop()
+      handleError(error, "Failed to search issues")
+    }
+  })
+
+function formatIssuesForDisplay(
+  issues: FetchedIssueSearchResult[],
+  showTeamColumn: boolean,
+  showAssigneeColumn: boolean,
+): string[] {
+  const { columns } = Deno.stdout.isTerminal()
+    ? Deno.consoleSize()
+    : { columns: 120 }
+
+  const priorityWidth = 3
+  const idWidth = Math.max(2, ...issues.map((issue) => issue.identifier.length))
+  const teamWidth = showTeamColumn
+    ? Math.max(4, ...issues.map((issue) => unicodeWidth(issue.team.key)))
+    : 0
+  const labelWidth = Math.min(
+    25,
+    Math.max(
+      6,
+      ...issues.map((issue) =>
+        unicodeWidth(
+          issue.labels.nodes.map((currentLabel) => currentLabel.name).join(
+            ", ",
+          ),
+        )
+      ),
+    ),
+  )
+  const assigneeWidth = showAssigneeColumn ? 2 : 0
+  const stateWidth = Math.min(
+    20,
+    Math.max(5, ...issues.map((issue) => unicodeWidth(issue.state.name))),
+  )
+  const updatedHeader = "UPDATED"
+  const updatedWidth = Math.max(
+    unicodeWidth(updatedHeader),
+    ...issues.map((issue) =>
+      unicodeWidth(getTimeAgo(new Date(issue.updatedAt)))
+    ),
+  )
+
+  const fixedCells = [
+    priorityWidth,
+    idWidth,
+    ...(showTeamColumn ? [teamWidth] : []),
+    labelWidth,
+    ...(showAssigneeColumn ? [assigneeWidth] : []),
+    stateWidth,
+    updatedWidth,
+  ]
+  const interCellSpacing = fixedCells.length + 1
+  const fixedWidth = fixedCells.reduce((sum, width) => sum + width, 0) +
+    interCellSpacing
+  const maxTitleWidth = Math.max(
+    ...issues.map((issue) => unicodeWidth(issue.title)),
+  )
+  const titleWidth = Math.max(10, Math.min(maxTitleWidth, columns - fixedWidth))
+
+  const headerCells = [
+    padDisplay("◌", priorityWidth),
+    padDisplay("ID", idWidth),
+    ...(showTeamColumn ? [padDisplay("TEAM", teamWidth)] : []),
+    padDisplay("TITLE", titleWidth),
+    padDisplay("LABELS", labelWidth),
+    ...(showAssigneeColumn ? [padDisplay("A", assigneeWidth)] : []),
+    padDisplay("STATE", stateWidth),
+    padDisplay(updatedHeader, updatedWidth),
+  ]
+
+  const outputLines = [header(headerCells.join(" "))]
+
+  for (const issue of issues) {
+    const title = padDisplay(truncateText(issue.title, titleWidth), titleWidth)
+    const stateName = truncateText(issue.state.name, stateWidth)
+    const coloredState = rgb24(
+      stateName,
+      parseInt(issue.state.color.replace("#", ""), 16),
+    )
+    const state = coloredState +
+      " ".repeat(Math.max(0, stateWidth - unicodeWidth(stateName)))
+    const timeAgo = muted(
+      padDisplay(getTimeAgo(new Date(issue.updatedAt)), updatedWidth),
+    )
+    const cells = [
+      padDisplay(getPriorityDisplay(issue.priority), priorityWidth),
+      padDisplay(issue.identifier, idWidth),
+      ...(showTeamColumn ? [padDisplay(issue.team.key, teamWidth)] : []),
+      title,
+      formatLabels(issue, labelWidth),
+      ...(showAssigneeColumn
+        ? [
+          padDisplay(
+            issue.assignee?.initials?.slice(0, 2) || "-",
+            assigneeWidth,
+          ),
+        ]
+        : []),
+      state,
+      timeAgo,
+    ]
+    outputLines.push(cells.join(" "))
+  }
+
+  return outputLines
+}
+
+function formatLabels(
+  issue: FetchedIssueSearchResult,
+  labelWidth: number,
+): string {
+  if (issue.labels.nodes.length === 0) {
+    return " ".repeat(labelWidth)
+  }
+
+  const coloredLabels: string[] = []
+  let currentWidth = 0
+
+  for (let i = 0; i < issue.labels.nodes.length; i++) {
+    const currentLabel = issue.labels.nodes[i]
+    const coloredLabel = rgb24(
+      currentLabel.name,
+      parseInt(currentLabel.color.replace("#", ""), 16),
+    )
+    const separator = i > 0 ? ", " : ""
+    const testText = separator + currentLabel.name
+
+    if (currentWidth + unicodeWidth(testText) > labelWidth) {
+      const remainingWidth = labelWidth - currentWidth
+      if (remainingWidth >= 4) {
+        const truncatedName = truncateText(
+          currentLabel.name,
+          remainingWidth - separator.length,
+        )
+        coloredLabels.push(
+          separator +
+            rgb24(
+              truncatedName,
+              parseInt(currentLabel.color.replace("#", ""), 16),
+            ),
+        )
+      }
+      break
+    }
+
+    coloredLabels.push(separator + coloredLabel)
+    currentWidth += unicodeWidth(testText)
+  }
+
+  const labels = coloredLabels.join("")
+  const ansiRegex = new RegExp("\u001B\\[[0-9;]*m", "g")
+  const visibleWidth = unicodeWidth(labels.replace(ansiRegex, ""))
+  return labels + " ".repeat(Math.max(0, labelWidth - visibleWidth))
+}
diff --git a/src/commands/issue/issue.ts b/src/commands/issue/issue.ts
index bce5ae38..602c3626 100644
--- a/src/commands/issue/issue.ts
+++ b/src/commands/issue/issue.ts
@@ -10,6 +10,7 @@ import { linkCommand } from "./issue-link.ts"
 import { listCommand } from "./issue-list.ts"
 import { pullRequestCommand } from "./issue-pull-request.ts"
 import { relationCommand } from "./issue-relation.ts"
+import { searchCommand } from "./issue-search.ts"
 import { agentSessionCommand } from "./issue-agent-session.ts"
 import { startCommand } from "./issue-start.ts"
 import { titleCommand } from "./issue-title.ts"
@@ -24,6 +25,7 @@ export const issueCommand = new Command()
   })
   .command("id", idCommand)
   .command("list", listCommand)
+  .command("search", searchCommand)
   .command("title", titleCommand)
   .command("start", startCommand)
   .command("view", viewCommand)
diff --git a/src/utils/linear.ts b/src/utils/linear.ts
index ea1cfdf7..37bbe691 100644
--- a/src/utils/linear.ts
+++ b/src/utils/linear.ts
@@ -8,6 +8,8 @@ import type {
   GetTeamMembersQuery,
   IssueFilter,
   IssueSortInput,
+  PaginationOrderBy,
+  SearchIssuesQuery,
 } from "../__codegen__/graphql.ts"
 import { Select } from "@cliffy/prompt"
 import { getOption } from "../config.ts"
@@ -640,6 +642,219 @@ export async function fetchIssuesForState(
   }
 }
 
+const searchIssuesQuery = gql(/* GraphQL */ `
+  query SearchIssues(
+    $term: String!
+    $filter: IssueFilter
+    $first: Int
+    $after: String
+    $includeArchived: Boolean
+    $includeComments: Boolean
+    $orderBy: PaginationOrderBy
+  ) {
+    searchIssues(
+      term: $term
+      filter: $filter
+      first: $first
+      after: $after
+      includeArchived: $includeArchived
+      includeComments: $includeComments
+      orderBy: $orderBy
+    ) {
+      nodes {
+        id
+        identifier
+        title
+        url
+        priority
+        priorityLabel
+        estimate
+        createdAt
+        updatedAt
+        state {
+          id
+          name
+          color
+          type
+        }
+        assignee {
+          id
+          name
+          displayName
+          initials
+        }
+        team {
+          id
+          key
+          name
+        }
+        project {
+          id
+          name
+        }
+        projectMilestone {
+          id
+          name
+        }
+        cycle {
+          id
+          number
+          name
+        }
+        labels {
+          nodes {
+            id
+            name
+            color
+          }
+        }
+        metadata
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+      totalCount
+    }
+  }
+`)
+
+type SearchIssuesPayload = SearchIssuesQuery["searchIssues"]
+
+export type FetchedIssueSearchResult = SearchIssuesPayload["nodes"][number]
+
+export type FetchedIssueSearchPayload = {
+  nodes: SearchIssuesPayload["nodes"]
+  pageInfo: SearchIssuesPayload["pageInfo"]
+  totalCount: SearchIssuesPayload["totalCount"]
+}
+
+export interface SearchIssuesByTermOptions {
+  teamKey?: string
+  state?: string[]
+  assignee?: string
+  unassigned?: boolean
+  limit?: number
+  projectId?: string
+  projectLabel?: string
+  labelNames?: string[]
+  createdAfter?: string
+  updatedAfter?: string
+  includeComments?: boolean
+  includeArchived?: boolean
+  orderBy?: PaginationOrderBy
+}
+
+export async function searchIssuesByTerm(
+  term: string,
+  options: SearchIssuesByTermOptions = {},
+): Promise<FetchedIssueSearchPayload> {
+  const filter: IssueFilter = {}
+
+  if (options.teamKey != null) {
+    filter.team = { key: { eq: options.teamKey } }
+  }
+
+  if (options.state != null && options.state.length > 0) {
+    filter.state = { type: { in: options.state } }
+  }
+
+  if (options.unassigned) {
+    filter.assignee = { null: true }
+  } else if (options.assignee) {
+    const userId = await lookupUserId(options.assignee)
+    if (!userId) {
+      throw new NotFoundError("User", options.assignee)
+    }
+    filter.assignee = { id: { eq: userId } }
+  }
+
+  if (options.projectId) {
+    filter.project = { id: { eq: options.projectId } }
+  } else if (options.projectLabel) {
+    filter.project = {
+      labels: { name: { eqIgnoreCase: options.projectLabel } },
+    }
+  }
+
+  if (options.labelNames != null && options.labelNames.length > 0) {
+    if (options.labelNames.length === 1) {
+      filter.labels = {
+        some: { name: { eqIgnoreCase: options.labelNames[0] } },
+      }
+    } else {
+      filter.labels = {
+        and: options.labelNames.map((name) => ({
+          some: { name: { eqIgnoreCase: name } },
+        })),
+      }
+    }
+  }
+
+  if (options.createdAfter) {
+    filter.createdAt = {
+      gte: parseDateFilter(options.createdAfter, "--created-after"),
+    }
+  }
+
+  if (options.updatedAfter) {
+    filter.updatedAt = {
+      gte: parseDateFilter(options.updatedAfter, "--updated-after"),
+    }
+  }
+
+  const client = getGraphQLClient()
+  const fetchUnlimited = options.limit === 0
+  const allNodes: SearchIssuesPayload["nodes"] = []
+  let totalCount = 0
+  let hasNextPage = true
+  let after: string | null | undefined = undefined
+  let lastPageInfo: SearchIssuesPayload["pageInfo"] = {
+    hasNextPage: false,
+    endCursor: null,
+  }
+
+  while (hasNextPage) {
+    const remaining = fetchUnlimited
+      ? 100
+      : (options.limit == null
+        ? undefined
+        : Math.min(options.limit - allNodes.length, 100))
+    if (!fetchUnlimited && remaining != null && remaining <= 0) {
+      break
+    }
+
+    const result: SearchIssuesQuery = await client.request(searchIssuesQuery, {
+      term,
+      filter: Object.keys(filter).length > 0 ? filter : undefined,
+      first: remaining,
+      after,
+      includeArchived: options.includeArchived,
+      includeComments: options.includeComments,
+      orderBy: options.orderBy,
+    })
+
+    totalCount = result.searchIssues.totalCount
+    allNodes.push(...result.searchIssues.nodes)
+    lastPageInfo = result.searchIssues.pageInfo
+    hasNextPage = result.searchIssues.pageInfo.hasNextPage
+    after = result.searchIssues.pageInfo.endCursor
+
+    if (
+      options.limit == null ||
+      (!fetchUnlimited && allNodes.length >= options.limit)
+    ) {
+      break
+    }
+  }
+
+  return {
+    nodes: allNodes,
+    pageInfo: lastPageInfo,
+    totalCount,
+  }
+}
+
 export async function getProjectIdByName(
   name: string,
 ): Promise<string | undefined> {
diff --git a/test/commands/issue/__snapshots__/issue-search.test.ts.snap b/test/commands/issue/__snapshots__/issue-search.test.ts.snap
new file mode 100644
index 00000000..6c8b6542
--- /dev/null
+++ b/test/commands/issue/__snapshots__/issue-search.test.ts.snap
@@ -0,0 +1,107 @@
+export const snapshot = {};
+
+snapshot[`Issue Search Command - Help Text 1`] = `
+stdout:
+\`
+Usage: search <term>
+
+Description:
+
+  Search issues by text
+
+Options:
+
+  -h, --help                          - Show this help.                                                                                                                     
+  --team              <team>          - Team to search in                                                                                                                   
+  --all-teams                         - Search across all teams                                                                                                             
+  -s, --state         <state>         - Filter by issue state (can be repeated for multiple states)                    (Values: \\x1b[32m"triage"\\x1b[39m, \\x1b[32m"backlog"\\x1b[39m, \\x1b[32m"unstarted"\\x1b[39m, \\x1b[32m"started"\\x1b[39m,
+                                                                                                                       \\x1b[32m"completed"\\x1b[39m, \\x1b[32m"canceled"\\x1b[39m)                             
+  --assignee          <assignee>      - Filter by assignee (username)                                                                                                       
+  -U, --unassigned                    - Show only unassigned issues                                                                                                         
+  --project           <project>       - Filter by project name                                                                                                              
+  --project-label     <projectLabel>  - Filter by project label name (shows issues from all projects with this label)                                                       
+  -l, --label         <label>         - Filter by label name (can be repeated for multiple labels)                                                                          
+  --include-comments                  - Search associated comments too                                                                                                      
+  --include-archived                  - Include archived issues                                                                                                             
+  --created-after     <date>          - Filter issues created after this date (ISO 8601 or YYYY-MM-DD)                                                                      
+  --updated-after     <date>          - Filter issues updated after this date (ISO 8601 or YYYY-MM-DD)                                                                      
+  --order-by          <orderBy>       - Use the API's supported search ordering                                        (Values: \\x1b[32m"createdAt"\\x1b[39m, \\x1b[32m"updatedAt"\\x1b[39m)                   
+  --limit             <limit>         - Maximum number of results to fetch (default: 20, use 0 for unlimited)          (Default: \\x1b[33m20\\x1b[39m)                                        
+  --no-pager                          - Disable automatic paging for long output                                                                                            
+  -j, --json                          - Output search results as JSON                                                                                                       
+
+\`
+stderr:
+""
+`;
+
+snapshot[`Issue Search Command - JSON Output 1`] = `
+stdout:
+'{
+  "nodes": [
+    {
+      "id": "issue-1",
+      "identifier": "CLI-90",
+      "title": "OAuth timeout in CLI auth flow",
+      "url": "https://linear.app/schpet/issue/CLI-90/oauth-timeout-in-cli-auth-flow",
+      "priority": 2,
+      "priorityLabel": "High",
+      "estimate": 3,
+      "createdAt": "2026-04-01T10:00:00.000Z",
+      "updatedAt": "2026-04-02T08:15:00.000Z",
+      "state": {
+        "id": "state-1",
+        "name": "In Progress",
+        "color": "#f2c94c",
+        "type": "started"
+      },
+      "assignee": {
+        "id": "user-1",
+        "name": "jane.smith",
+        "displayName": "Jane Smith",
+        "initials": "JS"
+      },
+      "team": {
+        "id": "team-1",
+        "key": "CLI",
+        "name": "Linear CLI"
+      },
+      "project": {
+        "id": "project-1",
+        "name": "Auth Improvements"
+      },
+      "projectMilestone": null,
+      "cycle": null,
+      "labels": {
+        "nodes": [
+          {
+            "id": "label-1",
+            "name": "Bug",
+            "color": "#eb5757"
+          }
+        ]
+      },
+      "metadata": {
+        "context": {},
+        "score": 0.42
+      }
+    }
+  ],
+  "pageInfo": {
+    "hasNextPage": false,
+    "endCursor": "cursor-1"
+  },
+  "totalCount": 1
+}
+'
+stderr:
+""
+`;
+
+snapshot[`Issue Search Command - No Results 1`] = `
+stdout:
+"No issues found.
+"
+stderr:
+""
+`;
diff --git a/test/commands/issue/issue-search.test.ts b/test/commands/issue/issue-search.test.ts
new file mode 100644
index 00000000..2af049e6
--- /dev/null
+++ b/test/commands/issue/issue-search.test.ts
@@ -0,0 +1,352 @@
+import { snapshotTest } from "@cliffy/testing"
+import { assertEquals } from "@std/assert"
+import { stub } from "@std/testing/mock"
+import { searchCommand } from "../../../src/commands/issue/issue-search.ts"
+import {
+  commonDenoArgs,
+  setupMockLinearServer,
+} from "../../utils/test-helpers.ts"
+
+await snapshotTest({
+  name: "Issue Search Command - Help Text",
+  meta: import.meta,
+  colors: false,
+  args: ["--help"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await searchCommand.parse()
+  },
+})
+
+await snapshotTest({
+  name: "Issue Search Command - JSON Output",
+  meta: import.meta,
+  colors: false,
+  args: [
+    "oauth timeout",
+    "--team",
+    "CLI",
+    "--include-comments",
+    "--order-by",
+    "updatedAt",
+    "--json",
+  ],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    const { cleanup } = await setupMockLinearServer([
+      {
+        queryName: "SearchIssues",
+        variables: {
+          term: "oauth timeout",
+          includeComments: true,
+          orderBy: "updatedAt",
+          first: 20,
+          filter: {
+            team: { key: { eq: "CLI" } },
+          },
+        },
+        response: {
+          data: {
+            searchIssues: {
+              nodes: [
+                {
+                  id: "issue-1",
+                  identifier: "CLI-90",
+                  title: "OAuth timeout in CLI auth flow",
+                  url:
+                    "https://linear.app/schpet/issue/CLI-90/oauth-timeout-in-cli-auth-flow",
+                  priority: 2,
+                  priorityLabel: "High",
+                  estimate: 3,
+                  createdAt: "2026-04-01T10:00:00.000Z",
+                  updatedAt: "2026-04-02T08:15:00.000Z",
+                  state: {
+                    id: "state-1",
+                    name: "In Progress",
+                    color: "#f2c94c",
+                    type: "started",
+                  },
+                  assignee: {
+                    id: "user-1",
+                    name: "jane.smith",
+                    displayName: "Jane Smith",
+                    initials: "JS",
+                  },
+                  team: {
+                    id: "team-1",
+                    key: "CLI",
+                    name: "Linear CLI",
+                  },
+                  project: {
+                    id: "project-1",
+                    name: "Auth Improvements",
+                  },
+                  projectMilestone: null,
+                  cycle: null,
+                  labels: {
+                    nodes: [
+                      {
+                        id: "label-1",
+                        name: "Bug",
+                        color: "#eb5757",
+                      },
+                    ],
+                  },
+                  metadata: {
+                    context: {},
+                    score: 0.42,
+                  },
+                },
+              ],
+              pageInfo: {
+                hasNextPage: false,
+                endCursor: "cursor-1",
+              },
+              totalCount: 1,
+            },
+          },
+        },
+      },
+    ], { NO_COLOR: "true" })
+
+    try {
+      await searchCommand.parse()
+    } finally {
+      await cleanup()
+    }
+  },
+})
+
+await snapshotTest({
+  name: "Issue Search Command - No Results",
+  meta: import.meta,
+  colors: false,
+  args: ["no matches here", "--team", "CLI"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    const { cleanup } = await setupMockLinearServer([
+      {
+        queryName: "SearchIssues",
+        variables: {
+          term: "no matches here",
+          first: 20,
+          filter: {
+            team: { key: { eq: "CLI" } },
+          },
+        },
+        response: {
+          data: {
+            searchIssues: {
+              nodes: [],
+              pageInfo: {
+                hasNextPage: false,
+                endCursor: null,
+              },
+              totalCount: 0,
+            },
+          },
+        },
+      },
+    ], { NO_COLOR: "true" })
+
+    try {
+      await searchCommand.parse()
+    } finally {
+      await cleanup()
+    }
+  },
+})
+
+Deno.test("Issue Search Command - limit 0 fetches all pages", async () => {
+  const { cleanup } = await setupMockLinearServer([
+    {
+      queryName: "SearchIssues",
+      variables: {
+        term: "issue",
+        first: 100,
+        after: undefined,
+        filter: {
+          team: { key: { eq: "CLI" } },
+        },
+      },
+      response: {
+        data: {
+          searchIssues: {
+            nodes: [
+              {
+                id: "issue-1",
+                identifier: "CLI-1",
+                title: "First issue",
+                url: "https://linear.app/schpet/issue/CLI-1/first-issue",
+                priority: 2,
+                priorityLabel: "High",
+                estimate: 3,
+                createdAt: "2026-04-01T10:00:00.000Z",
+                updatedAt: "2026-04-01T10:00:00.000Z",
+                state: {
+                  id: "state-1",
+                  name: "Backlog",
+                  color: "#999999",
+                  type: "backlog",
+                },
+                assignee: null,
+                team: {
+                  id: "team-1",
+                  key: "CLI",
+                  name: "Linear CLI",
+                },
+                project: null,
+                projectMilestone: null,
+                cycle: null,
+                labels: { nodes: [] },
+                metadata: {},
+              },
+            ],
+            pageInfo: {
+              hasNextPage: true,
+              endCursor: "cursor-1",
+            },
+            totalCount: 2,
+          },
+        },
+      },
+    },
+    {
+      queryName: "SearchIssues",
+      variables: {
+        term: "issue",
+        first: 100,
+        after: "cursor-1",
+        filter: {
+          team: { key: { eq: "CLI" } },
+        },
+      },
+      response: {
+        data: {
+          searchIssues: {
+            nodes: [
+              {
+                id: "issue-2",
+                identifier: "CLI-2",
+                title: "Second issue",
+                url: "https://linear.app/schpet/issue/CLI-2/second-issue",
+                priority: 3,
+                priorityLabel: "Normal",
+                estimate: null,
+                createdAt: "2026-04-02T10:00:00.000Z",
+                updatedAt: "2026-04-02T10:00:00.000Z",
+                state: {
+                  id: "state-2",
+                  name: "Started",
+                  color: "#f2c94c",
+                  type: "started",
+                },
+                assignee: null,
+                team: {
+                  id: "team-1",
+                  key: "CLI",
+                  name: "Linear CLI",
+                },
+                project: null,
+                projectMilestone: null,
+                cycle: null,
+                labels: { nodes: [] },
+                metadata: {},
+              },
+            ],
+            pageInfo: {
+              hasNextPage: false,
+              endCursor: "cursor-2",
+            },
+            totalCount: 2,
+          },
+        },
+      },
+    },
+  ], { NO_COLOR: "true" })
+
+  const logs: string[] = []
+  const logStub = stub(console, "log", (...args: unknown[]) => {
+    logs.push(args.map(String).join(" "))
+  })
+
+  try {
+    await searchCommand.parse([
+      "issue",
+      "--team",
+      "CLI",
+      "--limit",
+      "0",
+      "--json",
+    ])
+
+    assertEquals(JSON.parse(logs.join("\n")), {
+      nodes: [
+        {
+          id: "issue-1",
+          identifier: "CLI-1",
+          title: "First issue",
+          url: "https://linear.app/schpet/issue/CLI-1/first-issue",
+          priority: 2,
+          priorityLabel: "High",
+          estimate: 3,
+          createdAt: "2026-04-01T10:00:00.000Z",
+          updatedAt: "2026-04-01T10:00:00.000Z",
+          state: {
+            id: "state-1",
+            name: "Backlog",
+            color: "#999999",
+            type: "backlog",
+          },
+          assignee: null,
+          team: {
+            id: "team-1",
+            key: "CLI",
+            name: "Linear CLI",
+          },
+          project: null,
+          projectMilestone: null,
+          cycle: null,
+          labels: { nodes: [] },
+          metadata: {},
+        },
+        {
+          id: "issue-2",
+          identifier: "CLI-2",
+          title: "Second issue",
+          url: "https://linear.app/schpet/issue/CLI-2/second-issue",
+          priority: 3,
+          priorityLabel: "Normal",
+          estimate: null,
+          createdAt: "2026-04-02T10:00:00.000Z",
+          updatedAt: "2026-04-02T10:00:00.000Z",
+          state: {
+            id: "state-2",
+            name: "Started",
+            color: "#f2c94c",
+            type: "started",
+          },
+          assignee: null,
+          team: {
+            id: "team-1",
+            key: "CLI",
+            name: "Linear CLI",
+          },
+          project: null,
+          projectMilestone: null,
+          cycle: null,
+          labels: { nodes: [] },
+          metadata: {},
+        },
+      ],
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: "cursor-2",
+      },
+      totalCount: 2,
+    })
+  } finally {
+    logStub.restore()
+    await cleanup()
+  }
+})
diff --git a/test/utils/linear.test.ts b/test/utils/linear.test.ts
index 99c58219..3cfe402d 100644
--- a/test/utils/linear.test.ts
+++ b/test/utils/linear.test.ts
@@ -1,5 +1,9 @@
 import { assertEquals } from "@std/assert"
-import { getIssueIdentifier } from "../../src/utils/linear.ts"
+import {
+  getIssueIdentifier,
+  searchIssuesByTerm,
+} from "../../src/utils/linear.ts"
+import { setupMockLinearServer } from "../utils/test-helpers.ts"
 
 Deno.test("getIssueId - handles full issue identifiers", async () => {
   const result = await getIssueIdentifier("ABC-123")
@@ -32,3 +36,104 @@ Deno.test("getIssueId - rejects zero", async () => {
 
   Deno.env.delete("LINEAR_TEAM_ID")
 })
+
+Deno.test("searchIssuesByTerm - without limit fetches a single page", async () => {
+  const { cleanup } = await setupMockLinearServer([
+    {
+      queryName: "SearchIssues",
+      variables: {
+        term: "issue",
+        filter: {
+          team: { key: { eq: "CLI" } },
+        },
+      },
+      response: {
+        data: {
+          searchIssues: {
+            nodes: [
+              {
+                id: "issue-1",
+                identifier: "CLI-1",
+                title: "First issue",
+                url: "https://linear.app/schpet/issue/CLI-1/first-issue",
+                priority: 2,
+                priorityLabel: "High",
+                estimate: 3,
+                createdAt: "2026-04-01T10:00:00.000Z",
+                updatedAt: "2026-04-01T10:00:00.000Z",
+                state: {
+                  id: "state-1",
+                  name: "Backlog",
+                  color: "#999999",
+                  type: "backlog",
+                },
+                assignee: null,
+                team: {
+                  id: "team-1",
+                  key: "CLI",
+                  name: "Linear CLI",
+                },
+                project: null,
+                projectMilestone: null,
+                cycle: null,
+                labels: { nodes: [] },
+                metadata: {},
+              },
+            ],
+            pageInfo: {
+              hasNextPage: true,
+              endCursor: "cursor-1",
+            },
+            totalCount: 2,
+          },
+        },
+      },
+    },
+  ], { NO_COLOR: "true" })
+
+  try {
+    const result = await searchIssuesByTerm("issue", {
+      teamKey: "CLI",
+    })
+
+    assertEquals(result, {
+      nodes: [
+        {
+          id: "issue-1",
+          identifier: "CLI-1",
+          title: "First issue",
+          url: "https://linear.app/schpet/issue/CLI-1/first-issue",
+          priority: 2,
+          priorityLabel: "High",
+          estimate: 3,
+          createdAt: "2026-04-01T10:00:00.000Z",
+          updatedAt: "2026-04-01T10:00:00.000Z",
+          state: {
+            id: "state-1",
+            name: "Backlog",
+            color: "#999999",
+            type: "backlog",
+          },
+          assignee: null,
+          team: {
+            id: "team-1",
+            key: "CLI",
+            name: "Linear CLI",
+          },
+          project: null,
+          projectMilestone: null,
+          cycle: null,
+          labels: { nodes: [] },
+          metadata: {},
+        },
+      ],
+      pageInfo: {
+        hasNextPage: true,
+        endCursor: "cursor-1",
+      },
+      totalCount: 2,
+    })
+  } finally {
+    await cleanup()
+  }
+})