diff --git a/CHANGELOG.md b/CHANGELOG.md
index 72e60cf8..33c7c727 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@
 - `issue update --clear-due-date`, `--clear-estimate`, `--clear-parent`, `--clear-project`, and `--clear-milestone`, plus `project update --clear-lead`, `--clear-start-date`, and `--clear-target-date`, to remove a value the way `--unassign` and `--clear-cycle` already do. Each sends an explicit `null` to Linear and errors when combined with its set flag; `--clear-project` also rejects `--milestone`, since a milestone belongs to the project being removed. Previously these fields could only be changed, never cleared: cliffy treats `--due-date ""` as a missing value
 - `project update` now changes teams, labels, and initiatives with the same three operations `issue update` has for labels: `--team`, `--label`, and `--initiative` replace the whole set, `--add-team`/`--add-label`/`--add-initiative` append, and `--remove-team`/`--remove-label`/`--remove-initiative` detach, all repeatable, with a replace flag rejected alongside its add/remove flags. Linear's project input only accepts a full `teamIds`/`labelIds` list, so add and remove read the project's current set (every page of it) and send the computed set; initiatives have no input field at all and go through the initiative-to-project link mutations, so `project update` previously could not change them after `project create --initiative`. Removing a team, label, or initiative the project does not have errors and lists what it does have, and a link change that fails part-way reports what was applied and what is still pending
 - `--json` (`-j`) on `team list`, `cycle list`, `cycle view`, `milestone list`, `milestone view`, and `project view`, the last read commands without machine-readable output. List commands emit the same `{ nodes, pageInfo }` connection shape as the other list commands, after the same filtering and ordering as the table; view commands emit the GraphQL object as fetched, including every issue rather than the ten-item preview, and `milestone view --all --json` includes every page. (A 2.0.0 entry claimed `cycle list --json`; that change never actually landed.) ([#276](https://github.com/schpet/linear-cli/issues/276); thanks @lakardion)
+- `template list` and `template view`, and `--template <name|id>` on `issue create` and `project create`, mirroring what Linear's MCP server exposes. `template list` shows every issue, project, and document template in the workspace, filtered with `--type` and `--team` (a team's own templates plus workspace-level ones); `template view` prints a template's metadata and every value it pre-fills, with the rich-text body rendered as markdown, and `--json` on both returns the raw GraphQL objects with `templateData` still JSON-encoded. `--template` sends the template's ID so Linear applies it server-side: explicit flags override the template's values, `--label` merges with its labels, `--description` replaces its body (omit it to keep the body), and `issue create --template` makes `--title` optional. Linear rejects `useDefaultTemplate` next to `templateId`, so `--template` takes the place of the team's default template and `--no-use-default-template` is implied. Names resolve exactly and case-insensitively within the target type and team; a name shared by several eligible templates errors with their IDs. Document templates can be listed and viewed only: `DocumentCreateInput` has no `templateId`
 
 ### Fixed
 
diff --git a/README.md b/README.md
index e9c4e328..4578f01e 100644
--- a/README.md
+++ b/README.md
@@ -143,6 +143,7 @@ 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
 linear issue create --project "My Project" --milestone "Phase 1"  # create with milestone
+linear issue create --template "Bug report" -t "Login fails"  # create from a template (see template commands)
 linear issue update    # update an issue (interactive prompts)
 linear issue update ENG-123 --milestone "Phase 2"  # set milestone on existing issue
 linear issue update ENG-123 --clear-due-date --clear-parent  # remove values (also --clear-estimate, --clear-project, --clear-milestone, --clear-cycle, --unassign)
@@ -202,6 +203,7 @@ linear project view    # view project details
 linear project view <projectId> --json  # project details as JSON
 linear project create --name "API v2" --team ENG --content-file overview.md
 linear project create --name "Mobile launch" --team APP --priority high --label Launch --member jane@example.com
+linear project create --name "Q3 launch" --team APP --template "Kickoff"  # create from a project template
 linear project update <projectId> --content-file overview.md  # replace the project's overview body
 linear project update <projectId> --clear-lead --clear-target-date  # remove values (also --clear-start-date)
 linear project update <projectId> --add-team OPS --remove-label Launch --add-initiative "Q4 Bets"  # change teams, labels, initiatives incrementally
@@ -300,6 +302,23 @@ linear document delete --bulk <slug1> <slug2>   # bulk delete
 
 content updates are refused by default when a document has active inline Linear comments, because replacing markdown can detach or hide those anchors. top-level document comments do not block updates. review the inline comment first, then rerun with `--force` if you intentionally want to replace the content anyway.
 
+### template commands
+
+```bash
+linear template list                       # every issue, project, and document template in the workspace
+linear template list --type issue --team ENG  # ENG's issue templates plus workspace-level ones
+linear template list --json                # the raw template objects (templateData is a JSON-encoded string)
+linear template view "Bug report"          # what the template pre-fills: title, priority, labels, body, sub-issues, ...
+linear template view <template-id> --json  # raw GraphQL object; `jq '.templateData | fromjson'` decodes the data
+
+# apply a template on create (name or ID). Linear fills the template in server-side.
+linear issue create --team ENG --template "Bug report"                    # the template supplies the title
+linear issue create --team ENG --template "Bug report" -t "Login fails" -l security  # flags override, labels merge
+linear project create --name "Q3 launch" --team APP --template "Kickoff"
+```
+
+`--template` takes the place of the team's default template, so it never needs `--no-use-default-template` (passing both is fine). Anything you pass explicitly overrides the template's value; `--label` merges with the template's labels; `--description` replaces the template body, so leave it out to keep the body. Document templates can be listed and viewed, but Linear's API has no way to apply one when creating a document.
+
 ### other commands
 
 ```bash
diff --git a/docs/usage.md b/docs/usage.md
index 1356845c..38255d05 100644
--- a/docs/usage.md
+++ b/docs/usage.md
@@ -150,6 +150,21 @@ linear issue create --team TEAM
 linear issue create --start
 ```
 
+create from a template (name or ID, applied by Linear server-side):
+
+```bash
+# The template supplies the title, body, and fields; --title is optional
+linear issue create --team ENG --template "Bug report"
+
+# Flags you pass override the template's values; labels merge with the template's
+linear issue create --team ENG --template "Bug report" --title "Login fails" --label security
+
+# --description replaces the template body; leave it out to keep the body
+linear issue create --team ENG --template "Bug report" --description "Just this text"
+```
+
+`--template` takes the place of the team's default template (`--no-use-default-template` is implied; passing it too is fine). See [templates](#templates) for listing and inspecting them.
+
 #### update an issue
 
 update the current issue:
@@ -304,6 +319,9 @@ linear project create --name "API v2" --team ENG --content-file overview.md
 
 # Create with priority, labels, members, icon, and color
 linear project create --name "Mobile launch" --team APP --priority high --label Launch --member jane@example.com --icon rocket --color "#5E6AD2"
+
+# Create from a project template (name or ID); explicit flags override the template's values
+linear project create --name "Q3 launch" --team APP --template "Kickoff"
 ```
 
 #### update a project
@@ -366,6 +384,40 @@ linear initiative comment list "Platform"
 linear initiative comment add "Platform" --body "Scope locked for Q3"
 ```
 
+### templates
+
+Linear templates pre-fill an issue, project, or document. A template belongs to a team or to the whole workspace; team templates are only available in that team, workspace templates everywhere.
+
+#### list templates
+
+```bash
+linear template list                          # every template in the workspace
+linear template list --type issue             # issue, project, or document
+linear template list --team ENG               # ENG's templates plus workspace-level ones
+linear template list --type project --json    # raw template objects, after the same filtering and ordering as the table
+```
+
+#### view a template
+
+```bash
+linear template view "Bug report"             # by name (exact, case-insensitive)
+linear template view <template-id>            # by ID; needed when the same name exists in several teams
+linear template view "Bug report" --json      # raw GraphQL object
+linear template view "Bug report" --json | jq '.templateData | fromjson'   # decode the pre-filled data
+```
+
+The human view prints the template's metadata and then every key of its pre-filled data: title, priority, estimate, labels, state, sub-issues, and the body (Linear stores the body as rich text; it is shown as markdown). References come back as IDs, which `linear team states`, `linear label list`, and `linear user list` can map to names.
+
+#### apply a template
+
+Pass `--template <name|id>` to `issue create` or `project create`. Linear applies the template server-side on create; the CLI only sends the template's ID.
+
+- Anything you pass explicitly (title, priority, state, description, and so on) overrides the template's value.
+- `--label` merges with the template's labels rather than replacing them.
+- `--description` replaces the template body. Leave it out to keep the body.
+- `issue create --template` makes `--title` optional and takes the place of the team's default template (`--no-use-default-template` is implied and may be passed as well).
+- Document templates can be listed and viewed, but Linear's API offers no way to apply one when creating a document, so `document create` has no `--template` flag.
+
 ### shell completions
 
 generate shell completions for better command-line experience:
diff --git a/skills/linear-cli/SKILL.md b/skills/linear-cli/SKILL.md
index a85f0aa4..365cf62e 100644
--- a/skills/linear-cli/SKILL.md
+++ b/skills/linear-cli/SKILL.md
@@ -67,6 +67,17 @@ linear issue update ENG-123 --remove-label sprint-42 --add-label sprint-43  # at
 linear issue update ENG-123 --label infra --label security   # replaces the label set
 ```
 
+### Create an issue or project from a template
+
+```bash
+linear template list --type issue --team ENG              # find the template a team expects
+linear template view "Bug report"                         # see what it pre-fills (title, fields, body, sub-issues)
+linear issue create --team ENG --template "Bug report" --title "Login fails on Safari"
+linear project create --name "Q3 launch" --team ENG --template "Kickoff"
+```
+
+Explicit flags override the template's values, `--label` merges with its labels, and `--description` replaces its body (omit it to keep the body). Document templates cannot be applied through the API.
+
 ### Add a comment
 
 ```bash
@@ -277,6 +288,10 @@ linear team list
 linear team members
 linear team states
 
+linear template
+linear template list
+linear template view
+
 linear user
 linear user list
 ```
@@ -298,6 +313,7 @@ linear user list
 - [project-update](references/project-update.md) - Manage project status updates
 - [schema](references/schema.md) - Print the GraphQL schema to stdout
 - [team](references/team.md) - Manage Linear teams
+- [template](references/template.md) - Browse Linear issue, project, and document templates. Apply one with `issue create --template` or `project create --template`.
 - [user](references/user.md) - Manage Linear users
 
 For curated examples of organization features (initiatives, labels, projects, bulk operations), see [organization-features](references/organization-features.md).
diff --git a/skills/linear-cli/SKILL.template.md b/skills/linear-cli/SKILL.template.md
index e5986fe1..abc65972 100644
--- a/skills/linear-cli/SKILL.template.md
+++ b/skills/linear-cli/SKILL.template.md
@@ -67,6 +67,17 @@ linear issue update ENG-123 --remove-label sprint-42 --add-label sprint-43  # at
 linear issue update ENG-123 --label infra --label security   # replaces the label set
 ```
 
+### Create an issue or project from a template
+
+```bash
+linear template list --type issue --team ENG              # find the template a team expects
+linear template view "Bug report"                         # see what it pre-fills (title, fields, body, sub-issues)
+linear issue create --team ENG --template "Bug report" --title "Login fails on Safari"
+linear project create --name "Q3 launch" --team ENG --template "Kickoff"
+```
+
+Explicit flags override the template's values, `--label` merges with its labels, and `--description` replaces its body (omit it to keep the body). Document templates cannot be applied through the API.
+
 ### Add a comment
 
 ```bash
diff --git a/skills/linear-cli/references/commands.md b/skills/linear-cli/references/commands.md
index 27f34e56..2d392eb8 100644
--- a/skills/linear-cli/references/commands.md
+++ b/skills/linear-cli/references/commands.md
@@ -17,6 +17,7 @@
 - [project-update](./project-update.md) - Manage project status updates
 - [schema](./schema.md) - Print the GraphQL schema to stdout
 - [team](./team.md) - Manage Linear teams
+- [template](./template.md) - Browse Linear issue, project, and document templates. Apply one with `issue create --template` or `project create --template`.
 - [user](./user.md) - Manage Linear users
 
 ## Quick Reference
diff --git a/skills/linear-cli/references/issue.md b/skills/linear-cli/references/issue.md
index d3453c92..6c1413a5 100644
--- a/skills/linear-cli/references/issue.md
+++ b/skills/linear-cli/references/issue.md
@@ -278,6 +278,11 @@ Options:
   --cycle                    <cycle>        - Cycle name, number, 'active'/'now', 'next', 'previous', or a relative offset  
                                               like +1 (use --cycle=-1 for negatives)                                        
   --no-use-default-template                 - Do not use default template for the issue                                     
+  --template                 <template>     - Issue template to apply, by name or ID (the team's templates plus workspace   
+                                              ones). Takes the place of the team's default template. The template fills in  
+                                              anything you do not pass: explicit flags override it, --label merges with     
+                                              the template's labels, and --description replaces the template body (omit it  
+                                              to keep the body). Makes --title optional.                                    
   --no-interactive                          - Disable interactive prompts                                                   
   -t, --title                <title>        - Title of the issue
 ```
diff --git a/skills/linear-cli/references/project.md b/skills/linear-cli/references/project.md
index 1ec28cfb..b841d0ff 100644
--- a/skills/linear-cli/references/project.md
+++ b/skills/linear-cli/references/project.md
@@ -109,26 +109,29 @@ Description:
 
 Options:
 
-  -h, --help                             - Show this help.                                                             
-  --workspace             <slug>         - Target workspace (uses credentials)                                         
-  -n, --name              <name>         - Project name (required)                                                     
-  -d, --description       <description>  - Project description (max 255 characters, enforced by Linear's API)          
-  -f, --description-file  <path>         - Read project description from file (still subject to the 255-character API  
-                                           limit)                                                                      
-  --content               <markdown>     - Project overview markdown                                                   
-  --content-file          <path>         - Read project overview markdown from a file                                  
-  -t, --team              <team>         - Team key, name, or ID (required, can be repeated for multiple teams)        
-  -l, --lead              <lead>         - Project lead (username, email, or @me)                                      
-  -s, --status            <status>       - Project status (planned, started, paused, completed, canceled, backlog)     
-  --start-date            <startDate>    - Start date (YYYY-MM-DD)                                                     
-  --target-date           <targetDate>   - Target completion date (YYYY-MM-DD)                                         
-  --priority              <priority>     - Project priority (none, urgent, high, medium, low)                          
-  --label                 <label>        - Project label associated with the project. May be repeated.                 
-  --member                <user>         - Project member (username, email, display name, or @me). May be repeated.    
-  --icon                  <icon>         - Project icon                                                                
-  --color                 <color>        - Project color as a HEX string                                               
-  --initiative            <initiative>   - Add to initiative immediately (ID, slug, or name)                           
-  -i, --interactive                      - Interactive mode (default if no flags provided)                             
+  -h, --help                             - Show this help.                                                                  
+  --workspace             <slug>         - Target workspace (uses credentials)                                              
+  -n, --name              <name>         - Project name (required)                                                          
+  -d, --description       <description>  - Project description (max 255 characters, enforced by Linear's API)               
+  -f, --description-file  <path>         - Read project description from file (still subject to the 255-character API       
+                                           limit)                                                                           
+  --content               <markdown>     - Project overview markdown                                                        
+  --content-file          <path>         - Read project overview markdown from a file                                       
+  -t, --team              <team>         - Team key, name, or ID (required, can be repeated for multiple teams)             
+  -l, --lead              <lead>         - Project lead (username, email, or @me)                                           
+  -s, --status            <status>       - Project status (planned, started, paused, completed, canceled, backlog)          
+  --start-date            <startDate>    - Start date (YYYY-MM-DD)                                                          
+  --target-date           <targetDate>   - Target completion date (YYYY-MM-DD)                                              
+  --priority              <priority>     - Project priority (none, urgent, high, medium, low)                               
+  --label                 <label>        - Project label associated with the project. May be repeated.                      
+  --member                <user>         - Project member (username, email, display name, or @me). May be repeated.         
+  --icon                  <icon>         - Project icon                                                                     
+  --color                 <color>        - Project color as a HEX string                                                    
+  --initiative            <initiative>   - Add to initiative immediately (ID, slug, or name)                                
+  --template              <template>     - Project template to apply, by name or ID (workspace templates plus those of the  
+                                           project's teams). The template fills in anything you do not pass; explicit       
+                                           flags override it. Applied on create only.                                       
+  -i, --interactive                      - Interactive mode (default if no flags provided)                                  
   -j, --json                             - Output created project as JSON
 ```
 
diff --git a/skills/linear-cli/references/template.md b/skills/linear-cli/references/template.md
new file mode 100644
index 00000000..8e24549c
--- /dev/null
+++ b/skills/linear-cli/references/template.md
@@ -0,0 +1,64 @@
+# template
+
+> Browse Linear issue, project, and document templates. Apply one with `issue create --template` or `project create --template`.
+
+## Usage
+
+```
+Usage:   linear template
+
+Description:
+
+  Browse Linear issue, project, and document templates. Apply one with `issue create --template` or `project create --template`.
+
+Options:
+
+  -h, --help           - Show this help.                      
+  --workspace  <slug>  - Target workspace (uses credentials)  
+
+Commands:
+
+  list                 - List templates. Without --team, every template in the workspace is shown.
+  view, v  <template>  - Show a template and what it pre-fills. Pass its name or ID.
+```
+
+## Subcommands
+
+### list
+
+> List templates. Without --team, every template in the workspace is shown.
+
+```
+Usage:   linear template list
+
+Description:
+
+  List templates. Without --team, every template in the workspace is shown.
+
+Options:
+
+  -h, --help           - Show this help.                                                                                                       
+  --workspace  <slug>  - Target workspace (uses credentials)                                                                                   
+  --type       <type>  - Only templates of this type (issue, project, or document)                     (Values: "issue", "project", "document")
+  --team       <team>  - Team key, name, or ID. Shows that team's templates plus workspace templates.                                          
+  -j, --json           - Output as JSON
+```
+
+### view
+
+> Show a template and what it pre-fills. Pass its name or ID.
+
+```
+Usage:   linear template view <template>
+
+Description:
+
+  Show a template and what it pre-fills. Pass its name or ID.
+
+Options:
+
+  -h, --help           - Show this help.                                                                 
+  --workspace  <slug>  - Target workspace (uses credentials)                                             
+  -j, --json           - Output the template as JSON (templateData stays a JSON-encoded string; use `jq  
+                         '.templateData | fromjson'`)
+```
diff --git a/src/cli.ts b/src/cli.ts
index 22e95a74..7243fd3b 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -12,6 +12,7 @@ import { milestoneCommand } from "./commands/milestone/milestone.ts"
 import { initiativeCommand } from "./commands/initiative/initiative.ts"
 import { initiativeUpdateCommand } from "./commands/initiative-update/initiative-update.ts"
 import { labelCommand } from "./commands/label/label.ts"
+import { templateCommand } from "./commands/template/template.ts"
 import { documentCommand } from "./commands/document/document.ts"
 import { configCommand } from "./commands/config.ts"
 import { schemaCommand } from "./commands/schema.ts"
@@ -67,6 +68,7 @@ Environment Variables:
   .alias("iu")
   .command("label", labelCommand)
   .alias("l")
+  .command("template", templateCommand)
   .command("document", documentCommand)
   .command("completions", new CompletionsCommand())
   .command("config", configCommand)
diff --git a/src/commands/issue/issue-create.ts b/src/commands/issue/issue-create.ts
index 72215e97..78399702 100644
--- a/src/commands/issue/issue-create.ts
+++ b/src/commands/issue/issue-create.ts
@@ -39,6 +39,7 @@ import {
   ValidationError,
 } from "../../utils/errors.ts"
 import { withMarkdownHint } from "../../utils/markdown-help.ts"
+import { resolveTemplate } from "../../utils/templates.ts"
 
 type IssueLabel = { id: string; name: string; color: string }
 type ProjectOption = { id: string; name: string }
@@ -660,6 +661,10 @@ export const createCommand = new Command()
     "--no-use-default-template",
     "Do not use default template for the issue",
   )
+  .option(
+    "--template <template:string>",
+    "Issue template to apply, by name or ID (the team's templates plus workspace ones). Takes the place of the team's default template. The template fills in anything you do not pass: explicit flags override it, --label merges with the template's labels, and --description replaces the template body (omit it to keep the body). Makes --title optional.",
+  )
   .option("--no-interactive", "Disable interactive prompts")
   .option("-t, --title <title:string>", "Title of the issue")
   .action(
@@ -680,6 +685,7 @@ export const createCommand = new Command()
         state,
         milestone,
         cycle,
+        template,
         interactive,
         title,
       },
@@ -715,7 +721,7 @@ export const createCommand = new Command()
         !dueDate &&
         priority === undefined && estimate === undefined && !finalDescription &&
         (!labels || labels.length === 0) &&
-        !team && !state && !milestone && !cycle && !start
+        !team && !state && !milestone && !cycle && !start && template == null
 
       if (onlyInteractiveSeedFlagsProvided && interactive) {
         try {
@@ -785,13 +791,13 @@ export const createCommand = new Command()
         }
       }
 
-      // Fallback to flag-based mode
-      if (!title) {
+      // Fallback to flag-based mode. A template can supply the title.
+      if (!title && template == null) {
         throw new ValidationError(
           "Title is required when not using interactive mode",
           {
             suggestion:
-              "Use --title or run without any flags (or only --parent/--project) for interactive mode.",
+              "Use --title, pass --template to take the title from a template, or run without any flags (or only --parent/--project) for interactive mode.",
           },
         )
       }
@@ -831,6 +837,11 @@ export const createCommand = new Command()
             teamId = picked
           }
         }
+        // Linear rejects useDefaultTemplate next to templateId, so an explicit
+        // template also drops the default-template flag.
+        const templateId = template == null ? undefined : (
+          await resolveTemplate(template, { type: "issue", teamIds: [teamId] })
+        ).id
         if (start && assignee === undefined) {
           assignee = "self"
         }
@@ -932,7 +943,8 @@ export const createCommand = new Command()
           projectMilestoneId,
           cycleId,
           stateId,
-          useDefaultTemplate,
+          templateId,
+          useDefaultTemplate: template == null ? useDefaultTemplate : undefined,
           description: finalDescription,
         }
         spinner?.stop()
diff --git a/src/commands/project/project-create.ts b/src/commands/project/project-create.ts
index 6429a96d..8ed79266 100644
--- a/src/commands/project/project-create.ts
+++ b/src/commands/project/project-create.ts
@@ -23,6 +23,7 @@ import {
   resolveProjectDescription,
 } from "./project-description.ts"
 import { withMarkdownHint } from "../../utils/markdown-help.ts"
+import { resolveTemplate } from "../../utils/templates.ts"
 
 const CreateProject = gql(`
   mutation CreateProject($input: ProjectCreateInput!) {
@@ -214,6 +215,10 @@ export const createCommand = new Command()
     "--initiative <initiative:string>",
     "Add to initiative immediately (ID, slug, or name)",
   )
+  .option(
+    "--template <template:string>",
+    "Project template to apply, by name or ID (workspace templates plus those of the project's teams). The template fills in anything you do not pass; explicit flags override it. Applied on create only.",
+  )
   .option(
     "-i, --interactive",
     "Interactive mode (default if no flags provided)",
@@ -239,6 +244,7 @@ export const createCommand = new Command()
           icon: providedIcon,
           color: providedColor,
           initiative: providedInitiative,
+          template: providedTemplate,
           interactive: interactiveFlag,
           json: jsonOutput,
         } = options
@@ -391,6 +397,15 @@ export const createCommand = new Command()
         // Resolve team IDs
         const teamIds = (await resolveTeams(teams)).map((t) => t.id)
 
+        // A template must be a project template available to one of the
+        // project's teams (or a workspace template).
+        const templateId = providedTemplate == null ? undefined : (
+          await resolveTemplate(providedTemplate, {
+            type: "project",
+            teamIds,
+          })
+        ).id
+
         // Build input - resolve all optional fields first
         let leadId: string | undefined
         if (lead) {
@@ -474,6 +489,7 @@ export const createCommand = new Command()
           ...(memberIds.length > 0 && { memberIds }),
           ...(providedIcon != null && { icon: providedIcon }),
           ...(providedColor != null && { color: providedColor }),
+          ...(templateId != null && { templateId }),
         }
 
         const { Spinner } = await import("@std/cli/unstable-spinner")
diff --git a/src/commands/template/template-list.ts b/src/commands/template/template-list.ts
new file mode 100644
index 00000000..429950f2
--- /dev/null
+++ b/src/commands/template/template-list.ts
@@ -0,0 +1,138 @@
+import { Command, EnumType } from "@cliffy/command"
+import { unicodeWidth } from "@std/cli"
+import { padDisplay, truncateText } from "../../utils/display.ts"
+import { resolveTeam } from "../../utils/linear.ts"
+import { shouldShowSpinner } from "../../utils/hyperlink.ts"
+import { handleError } from "../../utils/errors.ts"
+import {
+  fetchTemplates,
+  type Template,
+  TEMPLATE_TYPES,
+  templateIsAvailableTo,
+  templateScopeLabel,
+} from "../../utils/templates.ts"
+
+const TemplateTypeArg = new EnumType(TEMPLATE_TYPES)
+
+/** Stable display order: type, then name, workspace templates before team ones. */
+function compareTemplates(a: Template, b: Template): number {
+  return a.type.localeCompare(b.type) ||
+    a.name.toLowerCase().localeCompare(b.name.toLowerCase()) ||
+    Number(a.team != null) - Number(b.team != null) ||
+    (a.team?.key ?? "").localeCompare(b.team?.key ?? "")
+}
+
+function typeCell(template: Template): string {
+  return template.hasFormFields ? `${template.type} (form)` : template.type
+}
+
+export const listCommand = new Command()
+  .name("list")
+  .description(
+    "List templates. Without --team, every template in the workspace is shown.",
+  )
+  .type("template-type", TemplateTypeArg)
+  .option(
+    "--type <type:template-type>",
+    "Only templates of this type (issue, project, or document)",
+  )
+  .option(
+    "--team <team:string>",
+    "Team key, name, or ID. Shows that team's templates plus workspace templates.",
+  )
+  .option("-j, --json", "Output as JSON")
+  .action(async ({ type, team: teamReference, json }) => {
+    const { Spinner } = await import("@std/cli/unstable-spinner")
+    const showSpinner = !json && shouldShowSpinner()
+    const spinner = showSpinner ? new Spinner() : null
+    spinner?.start()
+
+    try {
+      const team = teamReference == null
+        ? null
+        : await resolveTeam(teamReference)
+      const templates = (await fetchTemplates())
+        .filter((template) => type == null || template.type === type)
+        .filter((template) =>
+          team == null || templateIsAvailableTo(template, [team.id])
+        )
+        .sort(compareTemplates)
+
+      spinner?.stop()
+
+      if (json) {
+        console.log(JSON.stringify(templates, null, 2))
+        return
+      }
+
+      if (templates.length === 0) {
+        console.log("No templates found.")
+        return
+      }
+
+      const { columns } = Deno.stdout.isTerminal()
+        ? Deno.consoleSize()
+        : { columns: 120 }
+
+      const ID_WIDTH = 36
+      const TYPE_WIDTH = Math.max(
+        4,
+        ...templates.map((t) => unicodeWidth(typeCell(t))),
+      )
+      const TEAM_WIDTH = Math.min(
+        15,
+        Math.max(
+          4,
+          ...templates.map((t) => unicodeWidth(templateScopeLabel(t))),
+        ),
+      )
+      const SPACE_WIDTH = 3
+      const fixed = ID_WIDTH + TYPE_WIDTH + TEAM_WIDTH + SPACE_WIDTH
+      const maxNameWidth = Math.max(
+        4,
+        ...templates.map((t) => unicodeWidth(t.name)),
+      )
+      const availableWidth = Math.max(columns - 1 - fixed, 0)
+      const nameWidth = Math.min(maxNameWidth, Math.max(20, availableWidth))
+
+      const headerCells = [
+        padDisplay("ID", ID_WIDTH),
+        padDisplay("NAME", nameWidth),
+        padDisplay("TYPE", TYPE_WIDTH),
+        padDisplay("TEAM", TEAM_WIDTH),
+      ]
+      let headerMsg = ""
+      const headerStyles: string[] = []
+      headerCells.forEach((cell, index) => {
+        headerMsg += `%c${cell}`
+        headerStyles.push("text-decoration: underline")
+        if (index < headerCells.length - 1) {
+          headerMsg += "%c %c"
+          headerStyles.push("text-decoration: none")
+          headerStyles.push("text-decoration: underline")
+        }
+      })
+      console.log(headerMsg, ...headerStyles)
+
+      for (const template of templates) {
+        const name = padDisplay(
+          truncateText(template.name, nameWidth),
+          nameWidth,
+        )
+        console.log(
+          `${padDisplay(template.id, ID_WIDTH)} ${name} ${
+            padDisplay(typeCell(template), TYPE_WIDTH)
+          } ${padDisplay(templateScopeLabel(template), TEAM_WIDTH)}`,
+        )
+      }
+
+      console.log(
+        `\n${templates.length} ${
+          templates.length === 1 ? "template" : "templates"
+        } found.`,
+      )
+    } catch (error) {
+      spinner?.stop()
+      handleError(error, "Failed to list templates")
+    }
+  })
diff --git a/src/commands/template/template-view.ts b/src/commands/template/template-view.ts
new file mode 100644
index 00000000..754367f4
--- /dev/null
+++ b/src/commands/template/template-view.ts
@@ -0,0 +1,223 @@
+import { Command } from "@cliffy/command"
+import { renderMarkdown } from "@littletof/charmd"
+import { formatRelativeTime } from "../../utils/display.ts"
+import { shouldShowSpinner } from "../../utils/hyperlink.ts"
+import { handleError } from "../../utils/errors.ts"
+import { proseMirrorToMarkdown } from "../../utils/prosemirror.ts"
+import {
+  parseTemplateData,
+  resolveTemplate,
+  type Template,
+} from "../../utils/templates.ts"
+
+const INDENT = "  "
+
+/** Keys whose value is a ProseMirror document holding the template body. */
+const RICH_TEXT_KEYS = new Set(["descriptionData", "contentData"])
+
+const PRIORITY_NAMES: Record<number, string> = {
+  0: "none",
+  1: "urgent",
+  2: "high",
+  3: "medium",
+  4: "low",
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value != null && !Array.isArray(value)
+}
+
+function indentBlock(text: string, indent: string): string {
+  return text
+    .split("\n")
+    .map((line) => line.length > 0 ? `${indent}${line}` : line)
+    .join("\n")
+}
+
+const LABEL_KEYS = ["title", "name"]
+
+function itemLabel(item: Record<string, unknown>): string | null {
+  for (const key of LABEL_KEYS) {
+    const value = item[key]
+    if (typeof value === "string" && value.length > 0) {
+      return value
+    }
+  }
+  return null
+}
+
+function renderEntries(
+  entries: [string, unknown][],
+  indent: string,
+  lineWidth: number,
+): string[] {
+  // Scalars and references first, the body last, so the long part reads last.
+  const ordered = [
+    ...entries.filter(([key]) => !RICH_TEXT_KEYS.has(key)),
+    ...entries.filter(([key]) => RICH_TEXT_KEYS.has(key)),
+  ]
+  return ordered.flatMap(([key, value]) =>
+    renderPreFill(key, value, indent, lineWidth)
+  )
+}
+
+/**
+ * One pre-filled value. Every key is shown, at any depth: nested objects and
+ * the items of `subIssueData` / `issueData` keep all of their fields.
+ */
+function renderPreFill(
+  key: string,
+  value: unknown,
+  indent: string,
+  lineWidth: number,
+): string[] {
+  const nested = `${indent}${INDENT}`
+  if (RICH_TEXT_KEYS.has(key) && isRecord(value)) {
+    const markdown = proseMirrorToMarkdown(value)
+    const rendered = renderMarkdown(markdown, {
+      lineWidth: Math.max(20, lineWidth - nested.length),
+    })
+    return [`${indent}${key}:`, indentBlock(rendered.trimEnd(), nested)]
+  }
+  if (key === "priority" && typeof value === "number") {
+    const name = PRIORITY_NAMES[value]
+    return [`${indent}${key}: ${value}${name == null ? "" : ` (${name})`}`]
+  }
+  if (typeof value === "string") {
+    if (value.includes("\n")) {
+      return [`${indent}${key}:`, indentBlock(value.trimEnd(), nested)]
+    }
+    return [`${indent}${key}: ${value}`]
+  }
+  if (
+    typeof value === "number" || typeof value === "boolean" || value == null
+  ) {
+    return [`${indent}${key}: ${String(value)}`]
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [`${indent}${key}: (none)`]
+    }
+    if (value.every((item) => typeof item === "string")) {
+      return [`${indent}${key}: ${value.join(", ")}`]
+    }
+    return [
+      `${indent}${key}: ${value.length} ${
+        value.length === 1 ? "item" : "items"
+      }`,
+      ...value.flatMap((item) => renderItem(item, nested, lineWidth)),
+    ]
+  }
+  if (isRecord(value)) {
+    return [
+      `${indent}${key}:`,
+      ...renderEntries(Object.entries(value), nested, lineWidth),
+    ]
+  }
+  return [`${indent}${key}: ${JSON.stringify(value)}`]
+}
+
+/** An item of a list such as `subIssueData`: its label, then its other fields. */
+function renderItem(
+  item: unknown,
+  indent: string,
+  lineWidth: number,
+): string[] {
+  if (!isRecord(item)) {
+    return [`${indent}- ${JSON.stringify(item)}`]
+  }
+  const label = itemLabel(item)
+  const rest = Object.entries(item).filter(([key, value]) =>
+    !(label != null && LABEL_KEYS.includes(key) && value === label)
+  )
+  return [
+    `${indent}- ${label ?? "(untitled)"}`,
+    ...renderEntries(rest, `${indent}${INDENT}${INDENT}`, lineWidth),
+  ]
+}
+
+function capitalize(text: string): string {
+  return text.length === 0 ? text : text[0].toUpperCase() + text.slice(1)
+}
+
+export function formatTemplate(template: Template, lineWidth: number): string {
+  const data = parseTemplateData(template)
+  const lines: string[] = []
+
+  lines.push(template.name)
+  const scope = template.team == null
+    ? "Workspace"
+    : `Team ${template.team.key} (${template.team.name})`
+  lines.push(`${capitalize(template.type)} template · ${scope}`)
+  lines.push(`ID: ${template.id}`)
+  if (template.description != null && template.description.length > 0) {
+    lines.push(`Description: ${template.description}`)
+  }
+  if (template.hasFormFields) {
+    lines.push(
+      "Form template: yes (its form is filled in inside Linear; applying it from the CLI creates the entity with the form unanswered)",
+    )
+  }
+  if (template.inheritedFrom != null) {
+    lines.push(
+      `Inherited from: ${template.inheritedFrom.name} (${template.inheritedFrom.id})`,
+    )
+  }
+  if (template.creator != null) {
+    lines.push(`Created by: ${template.creator.name}`)
+  }
+  if (template.lastAppliedAt != null) {
+    lines.push(`Last applied: ${formatRelativeTime(template.lastAppliedAt)}`)
+  }
+  lines.push(`Updated: ${formatRelativeTime(template.updatedAt)}`)
+
+  lines.push("")
+  lines.push("Pre-fills:")
+  const entries = Object.entries(data)
+  if (entries.length === 0) {
+    lines.push(`${INDENT}(nothing)`)
+  }
+  lines.push(...renderEntries(entries, INDENT, lineWidth))
+  lines.push("")
+  lines.push(
+    "References are IDs. Map them with `linear team states`, `linear label list`, `linear user list`, or `linear project list`.",
+  )
+
+  return lines.join("\n")
+}
+
+export const viewCommand = new Command()
+  .name("view")
+  .description(
+    "Show a template and what it pre-fills. Pass its name or ID.",
+  )
+  .alias("v")
+  .arguments("<template:string>")
+  .option(
+    "-j, --json",
+    "Output the template as JSON (templateData stays a JSON-encoded string; use `jq '.templateData | fromjson'`)",
+  )
+  .action(async ({ json }, reference) => {
+    const { Spinner } = await import("@std/cli/unstable-spinner")
+    const showSpinner = !json && shouldShowSpinner()
+    const spinner = showSpinner ? new Spinner() : null
+    spinner?.start()
+
+    try {
+      const template = await resolveTemplate(reference)
+      spinner?.stop()
+
+      if (json) {
+        console.log(JSON.stringify(template, null, 2))
+        return
+      }
+
+      const lineWidth = Deno.stdout.isTerminal()
+        ? Deno.consoleSize().columns
+        : 80
+      console.log(formatTemplate(template, lineWidth))
+    } catch (error) {
+      spinner?.stop()
+      handleError(error, "Failed to view template")
+    }
+  })
diff --git a/src/commands/template/template.ts b/src/commands/template/template.ts
new file mode 100644
index 00000000..14d73a0d
--- /dev/null
+++ b/src/commands/template/template.ts
@@ -0,0 +1,13 @@
+import { Command } from "@cliffy/command"
+import { listCommand } from "./template-list.ts"
+import { viewCommand } from "./template-view.ts"
+
+export const templateCommand = new Command()
+  .description(
+    "Browse Linear issue, project, and document templates. Apply one with `issue create --template` or `project create --template`.",
+  )
+  .action(function () {
+    this.showHelp()
+  })
+  .command("list", listCommand)
+  .command("view", viewCommand)
diff --git a/src/utils/prosemirror.ts b/src/utils/prosemirror.ts
new file mode 100644
index 00000000..dc1ee9fc
--- /dev/null
+++ b/src/utils/prosemirror.ts
@@ -0,0 +1,271 @@
+import { ValidationError } from "./errors.ts"
+
+/**
+ * Best-effort conversion of a ProseMirror document (the shape Linear stores in
+ * a template's `descriptionData` / `contentData`) into Markdown, so a template
+ * body can be shown the way `issue view` shows an issue body. Nodes this
+ * converter does not know are rendered visibly instead of dropped.
+ */
+
+type Mark = {
+  type: string
+  attrs: Record<string, unknown>
+}
+
+type Node = {
+  type: string
+  attrs: Record<string, unknown>
+  content: Node[]
+  text: string | null
+  marks: Mark[]
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value != null && !Array.isArray(value)
+}
+
+function readMark(value: unknown, path: string): Mark {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    throw new ValidationError(
+      `Invalid ProseMirror mark at ${path}: expected an object with a string "type"`,
+    )
+  }
+  const attrs = value.attrs
+  return {
+    type: value.type,
+    attrs: isRecord(attrs) ? attrs : {},
+  }
+}
+
+function readNode(value: unknown, path: string): Node {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    throw new ValidationError(
+      `Invalid ProseMirror node at ${path}: expected an object with a string "type"`,
+    )
+  }
+  const content = value.content
+  if (content != null && !Array.isArray(content)) {
+    throw new ValidationError(
+      `Invalid ProseMirror node at ${path}: "content" must be an array`,
+    )
+  }
+  const marks = value.marks
+  if (marks != null && !Array.isArray(marks)) {
+    throw new ValidationError(
+      `Invalid ProseMirror node at ${path}: "marks" must be an array`,
+    )
+  }
+  const text = value.text
+  if (text != null && typeof text !== "string") {
+    throw new ValidationError(
+      `Invalid ProseMirror node at ${path}: "text" must be a string`,
+    )
+  }
+  const attrs = value.attrs
+  return {
+    type: value.type,
+    attrs: isRecord(attrs) ? attrs : {},
+    content: (content ?? []).map((child, index) =>
+      readNode(child, `${path}.content[${index}]`)
+    ),
+    text: text ?? null,
+    marks: (marks ?? []).map((mark, index) =>
+      readMark(mark, `${path}.marks[${index}]`)
+    ),
+  }
+}
+
+function attrString(attrs: Record<string, unknown>, key: string): string {
+  const value = attrs[key]
+  return typeof value === "string" ? value : ""
+}
+
+function attrNumber(
+  attrs: Record<string, unknown>,
+  key: string,
+  fallback: number,
+): number {
+  const value = attrs[key]
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback
+}
+
+/**
+ * Escape characters that Markdown would otherwise interpret, so literal text
+ * from the template (an asterisk, a backtick, a leading "1.") survives the
+ * Markdown renderer unchanged.
+ */
+function escapeMarkdown(text: string): string {
+  return text
+    .replace(/[\\*_`\[\]~<>#]/g, (char) => `\\${char}`)
+    // A leading "-", "+", or "1." would start a list; a bare number is fine.
+    .replace(
+      /^([ \t]*)(?:([-+])|(\d+)\.)(?=\s)/gm,
+      (_match, space, bullet, number) =>
+        bullet != null ? `${space}\\${bullet}` : `${space}${number}\\.`,
+    )
+}
+
+function longestBacktickRun(text: string): number {
+  return Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length))
+}
+
+/** A code span whose fence is longer than any backtick run inside it. */
+function codeSpan(text: string): string {
+  const longest = longestBacktickRun(text)
+  const fence = "`".repeat(longest + 1)
+  return longest === 0 ? `${fence}${text}${fence}` : `${fence} ${text} ${fence}`
+}
+
+function applyMarks(text: string, marks: Mark[]): string {
+  const isCode = marks.some((mark) => mark.type === "code")
+  let result = isCode ? codeSpan(text) : escapeMarkdown(text)
+  for (const mark of marks) {
+    switch (mark.type) {
+      case "bold":
+      case "strong":
+        result = `**${result}**`
+        break
+      case "italic":
+      case "em":
+        result = `_${result}_`
+        break
+      case "code":
+        // Already fenced above, before the other marks wrap it.
+        break
+      case "strike":
+      case "strikethrough":
+        result = `~~${result}~~`
+        break
+      case "link": {
+        const href = attrString(mark.attrs, "href")
+        result = href.length > 0 ? `[${result}](${href})` : result
+        break
+      }
+      default:
+        // Underline, text color, and other decorations have no Markdown form.
+        break
+    }
+  }
+  return result
+}
+
+function renderInline(nodes: Node[]): string {
+  return nodes.map((node) => {
+    switch (node.type) {
+      case "text":
+        return applyMarks(node.text ?? "", node.marks)
+      case "hard_break":
+        return "\n"
+      case "image":
+        return `![${attrString(node.attrs, "alt")}](${
+          attrString(node.attrs, "src")
+        })`
+      default: {
+        // Mentions and similar inline atoms carry their display text in attrs.
+        const label = attrString(node.attrs, "label")
+        if (label.length > 0) {
+          return applyMarks(label, node.marks)
+        }
+        if (node.text != null) {
+          return applyMarks(node.text, node.marks)
+        }
+        if (node.content.length > 0) {
+          return renderInline(node.content)
+        }
+        return `[${node.type}]`
+      }
+    }
+  }).join("")
+}
+
+function indentContinuation(text: string, indent: string): string {
+  const lines = text.split("\n")
+  return lines
+    .map((line, index) =>
+      index === 0 || line.length === 0 ? line : `${indent}${line}`
+    )
+    .join("\n")
+}
+
+function renderListItems(
+  items: Node[],
+  marker: (item: Node, index: number) => string,
+): string {
+  return items.map((item, index) => {
+    const prefix = marker(item, index)
+    const indent = " ".repeat(prefix.length)
+    const body = item.type === "list_item" || item.type === "todo_item"
+      ? renderBlocks(item.content)
+      : renderBlock(item)
+    return `${prefix}${indentContinuation(body, indent)}`
+  }).join("\n")
+}
+
+function renderBlock(node: Node): string {
+  switch (node.type) {
+    case "paragraph":
+      return renderInline(node.content)
+    case "heading": {
+      const level = Math.min(6, Math.max(1, attrNumber(node.attrs, "level", 1)))
+      return `${"#".repeat(level)} ${renderInline(node.content)}`
+    }
+    case "bullet_list":
+      return renderListItems(node.content, () => "- ")
+    case "ordered_list": {
+      const start = attrNumber(node.attrs, "order", 1)
+      return renderListItems(
+        node.content,
+        (_item, index) => `${start + index}. `,
+      )
+    }
+    case "todo_list":
+      return renderListItems(node.content, (item) => {
+        const done = item.attrs.done === true || item.attrs.checked === true
+        return done ? "- [x] " : "- [ ] "
+      })
+    case "code_block": {
+      const language = attrString(node.attrs, "language")
+      const code = node.content.map((child) => child.text ?? "").join("")
+      // The fence must be longer than any backtick run inside the code.
+      const fence = "`".repeat(Math.max(3, longestBacktickRun(code) + 1))
+      return `${fence}${language}\n${code}\n${fence}`
+    }
+    case "blockquote":
+      return renderBlocks(node.content)
+        .split("\n")
+        .map((line) => `> ${line}`)
+        .join("\n")
+    case "horizontal_rule":
+      return "---"
+    case "text":
+    case "hard_break":
+    case "image":
+      return renderInline([node])
+    default:
+      if (node.content.length > 0) {
+        return renderBlocks(node.content)
+      }
+      if (node.text != null) {
+        return applyMarks(node.text, node.marks)
+      }
+      return `[unsupported ${node.type} node]`
+  }
+}
+
+function renderBlocks(nodes: Node[]): string {
+  return nodes.map(renderBlock).join("\n\n")
+}
+
+/**
+ * Convert a ProseMirror document to Markdown. Throws a ValidationError when
+ * the value is not a ProseMirror document at all.
+ */
+export function proseMirrorToMarkdown(doc: unknown): string {
+  const root = readNode(doc, "doc")
+  if (root.type !== "doc") {
+    throw new ValidationError(
+      `Expected a ProseMirror document, got a "${root.type}" node`,
+    )
+  }
+  return renderBlocks(root.content).trimEnd()
+}
diff --git a/src/utils/templates.ts b/src/utils/templates.ts
new file mode 100644
index 00000000..87051e0e
--- /dev/null
+++ b/src/utils/templates.ts
@@ -0,0 +1,305 @@
+import { gql } from "../__codegen__/gql.ts"
+import type { GetTemplatesQuery } from "../__codegen__/graphql.ts"
+import { getGraphQLClient } from "./graphql.ts"
+import { isLinearUuid } from "./linear.ts"
+import {
+  CliError,
+  isClientError,
+  NotFoundError,
+  ValidationError,
+} from "./errors.ts"
+
+/**
+ * Template types the CLI knows how to filter by and apply. Linear stores the
+ * type as a plain string, so other types may exist; listing without a filter
+ * keeps them.
+ */
+export const TEMPLATE_TYPES = ["issue", "project", "document"] as const
+export type TemplateType = (typeof TEMPLATE_TYPES)[number]
+
+// Both documents select the same fields so a template looks identical whether
+// it was reached by name (through the workspace list) or by ID.
+const GetTemplates = gql(`
+  query GetTemplates {
+    templates {
+      id
+      name
+      description
+      type
+      icon
+      color
+      hasFormFields
+      lastAppliedAt
+      sortOrder
+      createdAt
+      updatedAt
+      team {
+        id
+        key
+        name
+      }
+      inheritedFrom {
+        id
+        name
+      }
+      creator {
+        id
+        name
+      }
+      templateData
+    }
+  }
+`)
+
+const GetTemplate = gql(`
+  query GetTemplate($id: String!) {
+    template(id: $id) {
+      id
+      name
+      description
+      type
+      icon
+      color
+      hasFormFields
+      lastAppliedAt
+      sortOrder
+      createdAt
+      updatedAt
+      team {
+        id
+        key
+        name
+      }
+      inheritedFrom {
+        id
+        name
+      }
+      creator {
+        id
+        name
+      }
+      templateData
+    }
+  }
+`)
+
+export type Template = GetTemplatesQuery["templates"][number]
+
+/**
+ * Where a template must be usable from. A template qualifies when it is a
+ * workspace template (no team) or belongs to one of the given teams, and its
+ * type matches.
+ */
+export type TemplateScope = {
+  type: TemplateType
+  teamIds: readonly string[]
+}
+
+export function templateIsAvailableTo(
+  template: Pick<Template, "team">,
+  teamIds: readonly string[],
+): boolean {
+  return template.team == null || teamIds.includes(template.team.id)
+}
+
+export function templateScopeLabel(template: Pick<Template, "team">): string {
+  return template.team == null ? "Workspace" : template.team.key
+}
+
+/** Every template in the workspace, team-scoped and workspace-level alike. */
+export async function fetchTemplates(): Promise<Template[]> {
+  const client = getGraphQLClient()
+  const result = await client.request(GetTemplates)
+  return result.templates
+}
+
+/**
+ * One template by UUID. `template(id:)` is non-null, so Linear answers a
+ * missing UUID with a GraphQL error ("No template found with id ...") rather
+ * than a null field; translate that into a NotFoundError.
+ */
+export async function fetchTemplate(id: string): Promise<Template> {
+  const client = getGraphQLClient()
+  try {
+    const result = await client.request(GetTemplate, { id })
+    return result.template
+  } catch (error) {
+    if (
+      isClientError(error) &&
+      (error.response.errors ?? []).some((graphqlError) =>
+        /no template found/i.test(graphqlError.message)
+      )
+    ) {
+      throw new NotFoundError("Template", id, {
+        suggestion: "Run `linear template list` to see every template.",
+      })
+    }
+    throw error
+  }
+}
+
+function describeType(type: string): string {
+  const article = /^[aeiou]/i.test(type) ? "an" : "a"
+  return `${article} ${type} template`
+}
+
+function wrongTypeError(
+  template: Template,
+  scope: TemplateScope,
+): ValidationError {
+  return new ValidationError(
+    `Template "${template.name}" is ${describeType(template.type)}, not ${
+      describeType(scope.type)
+    }`,
+    {
+      suggestion:
+        `Run \`linear template list --type ${scope.type}\` to see the ${scope.type} templates.`,
+    },
+  )
+}
+
+function otherTeamError(
+  name: string,
+  teamKeys: string[],
+  scope: TemplateScope,
+): ValidationError {
+  const teams = teamKeys.join(", ")
+  return new ValidationError(
+    `Template "${name}" belongs to team${
+      teamKeys.length === 1 ? "" : "s"
+    } ${teams} and cannot be applied here`,
+    {
+      suggestion: `Pass --team ${
+        teamKeys[0]
+      }, or pick a workspace template or one from the target team with \`linear template list --type ${scope.type} --team <team>\`.`,
+    },
+  )
+}
+
+/** Why none of several same-named templates qualified, preferring the team mismatch: it is the actionable one. */
+function scopeMismatchError(
+  matches: Template[],
+  scope: TemplateScope,
+): ValidationError {
+  const sameType = matches.filter((template) => template.type === scope.type)
+  if (sameType.length > 0) {
+    const teamKeys = [
+      ...new Set(
+        sameType.flatMap((template) =>
+          template.team == null ? [] : [template.team.key]
+        ),
+      ),
+    ]
+    if (teamKeys.length > 0) {
+      return otherTeamError(sameType[0].name, teamKeys, scope)
+    }
+  }
+  return wrongTypeError(matches[0], scope)
+}
+
+function assertTemplateInScope(template: Template, scope: TemplateScope): void {
+  if (template.type !== scope.type) {
+    throw wrongTypeError(template, scope)
+  }
+  if (!templateIsAvailableTo(template, scope.teamIds)) {
+    const team = template.team
+    if (team == null) {
+      throw new CliError(`Template "${template.name}" is not available here`)
+    }
+    throw otherTeamError(template.name, [team.key], scope)
+  }
+}
+
+/**
+ * Resolve a template reference (UUID or exact, case-insensitive name) to a
+ * template. With a scope, only templates of that type that are available to
+ * those teams qualify, so a same-named template of another team never causes
+ * ambiguity. A reference that matches nothing errors with the names that would
+ * have qualified; a reference that matches several errors with their IDs.
+ */
+export async function resolveTemplate(
+  reference: string,
+  scope?: TemplateScope,
+): Promise<Template> {
+  if (isLinearUuid(reference)) {
+    const template = await fetchTemplate(reference)
+    if (scope != null) {
+      assertTemplateInScope(template, scope)
+    }
+    return template
+  }
+
+  const all = await fetchTemplates()
+  const wanted = reference.toLowerCase()
+  const byName = all.filter((template) =>
+    template.name.toLowerCase() === wanted
+  )
+  const inScope = (template: Template): boolean =>
+    scope == null ||
+    (template.type === scope.type &&
+      templateIsAvailableTo(template, scope.teamIds))
+  const candidates = byName.filter(inScope)
+
+  if (candidates.length === 1) {
+    return candidates[0]
+  }
+
+  if (candidates.length === 0) {
+    if (byName.length > 0 && scope != null) {
+      // The name exists, just not for this type or team: say why.
+      throw scopeMismatchError(byName, scope)
+    }
+    const what = scope == null ? "templates" : `${scope.type} templates`
+    const names = [...new Set(all.filter(inScope).map((t) => t.name))]
+      .sort((a, b) => a.localeCompare(b))
+    const suggestion = names.length > 0
+      ? `Available ${what}: ${
+        names.map((name) => `"${name}"`).join(", ")
+      }. Run \`linear template list\` to see every template.`
+      : `No ${what} are available here. Run \`linear template list\` to see every template.`
+    throw new NotFoundError("Template", reference, { suggestion })
+  }
+
+  throw new ValidationError(
+    `Template name "${reference}" is ambiguous: it matches ${candidates.length} templates`,
+    {
+      suggestion: `Pass the template ID instead: ${
+        candidates
+          .map((t) => `${t.id} (${t.type}, ${templateScopeLabel(t)})`)
+          .join(", ")
+      }`,
+    },
+  )
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value != null && !Array.isArray(value)
+}
+
+/**
+ * The pre-filled attributes of a template. Linear returns `templateData` as a
+ * JSON-encoded string inside the JSON scalar; accept an already-decoded object
+ * too, and reject anything else loudly.
+ */
+export function parseTemplateData(
+  template: Pick<Template, "id" | "name" | "templateData">,
+): Record<string, unknown> {
+  const raw: unknown = template.templateData
+  let decoded: unknown = raw
+  if (typeof raw === "string") {
+    try {
+      decoded = JSON.parse(raw)
+    } catch (error) {
+      throw new CliError(
+        `Template data for "${template.name}" (${template.id}) is not valid JSON`,
+        { cause: error },
+      )
+    }
+  }
+  if (!isRecord(decoded)) {
+    throw new CliError(
+      `Template data for "${template.name}" (${template.id}) is not a JSON object`,
+    )
+  }
+  return decoded
+}
diff --git a/test/commands/issue/__snapshots__/issue-create.test.ts.snap b/test/commands/issue/__snapshots__/issue-create.test.ts.snap
index 963d6102..18b998a0 100644
--- a/test/commands/issue/__snapshots__/issue-create.test.ts.snap
+++ b/test/commands/issue/__snapshots__/issue-create.test.ts.snap
@@ -33,6 +33,11 @@ Options:
   --cycle                    <cycle>        - Cycle name, number, 'active'/'now', 'next', 'previous', or a relative offset  
                                               like +1 (use --cycle=-1 for negatives)                                        
   --no-use-default-template                 - Do not use default template for the issue                                     
+  --template                 <template>     - Issue template to apply, by name or ID (the team's templates plus workspace   
+                                              ones). Takes the place of the team's default template. The template fills in  
+                                              anything you do not pass: explicit flags override it, --label merges with     
+                                              the template's labels, and --description replaces the template body (omit it  
+                                              to keep the body). Makes --title optional.                                    
   --no-interactive                          - Disable interactive prompts                                                   
   -t, --title                <title>        - Title of the issue                                                            
 
@@ -118,3 +123,23 @@ https://linear.app/test-team/issue/ENG-1/by-name
 stderr:
 ""
 `;
+
+snapshot[`Issue Create Command - With Template By Name 1`] = `
+stdout:
+"Creating issue in ENG
+
+https://linear.app/test-team/issue/ENG-321/from-template
+"
+stderr:
+""
+`;
+
+snapshot[`Issue Create Command - Template Supplies The Title 1`] = `
+stdout:
+"Creating issue in ENG
+
+https://linear.app/test-team/issue/ENG-321/from-template
+"
+stderr:
+""
+`;
diff --git a/test/commands/issue/issue-create.test.ts b/test/commands/issue/issue-create.test.ts
index e561e473..4604e274 100644
--- a/test/commands/issue/issue-create.test.ts
+++ b/test/commands/issue/issue-create.test.ts
@@ -1,9 +1,11 @@
 import { snapshotTest } from "@cliffy/testing"
-import { assertEquals, assertStringIncludes } from "@std/assert"
+import { assertEquals, assertRejects, assertStringIncludes } from "@std/assert"
 import { Checkbox, Input, Select } from "@cliffy/prompt"
 import { stub } from "@std/testing/mock"
 import { createCommand } from "../../../src/commands/issue/issue-create.ts"
+import { ValidationError } from "../../../src/utils/errors.ts"
 import {
+  captureCommandError,
   commonDenoArgs,
   resolveTeamMock,
   setupMockLinearServer,
@@ -1691,3 +1693,219 @@ await snapshotTest({
     }
   },
 })
+
+// --template: the template is resolved against the team and sent as
+// templateId, with useDefaultTemplate left out (Linear rejects the pair).
+const BUG_TEMPLATE_ID = "11111111-1111-4111-8111-111111111111"
+const KICKOFF_TEMPLATE_ID = "22222222-2222-4222-8222-222222222222"
+
+function templateFixture(
+  id: string,
+  name: string,
+  type: string,
+  team: { id: string; key: string; name: string } | null,
+) {
+  return {
+    id,
+    name,
+    description: null,
+    type,
+    icon: null,
+    color: null,
+    hasFormFields: false,
+    lastAppliedAt: null,
+    sortOrder: 0,
+    createdAt: "2024-01-01T00:00:00.000Z",
+    updatedAt: "2024-01-01T00:00:00.000Z",
+    team,
+    inheritedFrom: null,
+    creator: null,
+    templateData: '{"title":"Bug: ","priority":2}',
+  }
+}
+
+const templatesMock = {
+  queryName: "GetTemplates",
+  response: {
+    data: {
+      templates: [
+        templateFixture(BUG_TEMPLATE_ID, "Bug report", "issue", {
+          id: "team-eng-id",
+          key: "ENG",
+          name: "Engineering",
+        }),
+        templateFixture(KICKOFF_TEMPLATE_ID, "Kickoff", "project", null),
+      ],
+    },
+  },
+}
+
+function createdIssueMock(variables: Record<string, unknown>) {
+  return {
+    queryName: "CreateIssue",
+    variables,
+    response: {
+      data: {
+        issueCreate: {
+          success: true,
+          issue: {
+            id: "issue-from-template",
+            identifier: "ENG-321",
+            url: "https://linear.app/test-team/issue/ENG-321/from-template",
+            team: { key: "ENG" },
+          },
+        },
+      },
+    },
+  }
+}
+
+await snapshotTest({
+  name: "Issue Create Command - With Template By Name",
+  meta: import.meta,
+  colors: false,
+  args: [
+    "--title",
+    "Login fails on Safari",
+    "--team",
+    "ENG",
+    "--template",
+    "bug report",
+    "--no-interactive",
+  ],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    const { cleanup } = await setupMockLinearServer([
+      resolveTeamMock("ENG"),
+      templatesMock,
+      // Exact key set: the request body carries only defined fields, so an
+      // accidental useDefaultTemplate (true or false) would not match.
+      createdIssueMock({
+        input: {
+          title: "Login fails on Safari",
+          labelIds: [],
+          teamId: "team-eng-id",
+          templateId: BUG_TEMPLATE_ID,
+        },
+      }),
+    ])
+
+    try {
+      await createCommand.parse()
+    } finally {
+      await cleanup()
+    }
+  },
+})
+
+await snapshotTest({
+  name: "Issue Create Command - Template Supplies The Title",
+  meta: import.meta,
+  colors: false,
+  args: [
+    "--team",
+    "ENG",
+    "--template",
+    BUG_TEMPLATE_ID,
+    "--no-use-default-template",
+    "--no-interactive",
+  ],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    const { cleanup } = await setupMockLinearServer([
+      resolveTeamMock("ENG"),
+      {
+        queryName: "GetTemplate",
+        variables: { id: BUG_TEMPLATE_ID },
+        response: {
+          data: {
+            template: templateFixture(BUG_TEMPLATE_ID, "Bug report", "issue", {
+              id: "team-eng-id",
+              key: "ENG",
+              name: "Engineering",
+            }),
+          },
+        },
+      },
+      createdIssueMock({
+        input: {
+          labelIds: [],
+          teamId: "team-eng-id",
+          templateId: BUG_TEMPLATE_ID,
+        },
+      }),
+    ])
+
+    try {
+      await createCommand.parse()
+    } finally {
+      await cleanup()
+    }
+  },
+})
+
+Deno.test("Issue Create Command - a project template is rejected before the mutation", async () => {
+  // No CreateIssue mock: reaching the mutation would surface a different error.
+  const { cleanup } = await setupMockLinearServer([
+    resolveTeamMock("ENG"),
+    templatesMock,
+  ])
+  try {
+    const output = await captureCommandError(() =>
+      createCommand.parse([
+        "--title",
+        "Plan the launch",
+        "--team",
+        "ENG",
+        "--template",
+        "Kickoff",
+        "--no-interactive",
+      ])
+    )
+    assertStringIncludes(
+      output,
+      '✗ Failed to create issue: Template "Kickoff" is a project template, not an issue template',
+    )
+  } finally {
+    await cleanup()
+  }
+})
+
+Deno.test("Issue Create Command - an unknown template lists the team's issue templates", async () => {
+  const { cleanup } = await setupMockLinearServer([
+    resolveTeamMock("ENG"),
+    templatesMock,
+  ])
+  try {
+    const output = await captureCommandError(() =>
+      createCommand.parse([
+        "--title",
+        "Plan the launch",
+        "--team",
+        "ENG",
+        "--template",
+        "Incident",
+        "--no-interactive",
+      ])
+    )
+    assertStringIncludes(
+      output,
+      "✗ Failed to create issue: Template not found: Incident",
+    )
+    assertStringIncludes(output, 'Available issue templates: "Bug report".')
+  } finally {
+    await cleanup()
+  }
+})
+
+Deno.test("Issue Create Command - a title is still required without a template", async () => {
+  const error = await assertRejects(
+    () => createCommand.parse(["--team", "ENG", "--no-interactive"]),
+    ValidationError,
+    "Title is required when not using interactive mode",
+  )
+  assertStringIncludes(
+    error.suggestion ?? "",
+    "pass --template to take the title from a template",
+  )
+})
diff --git a/test/commands/project/__snapshots__/project-create.test.ts.snap b/test/commands/project/__snapshots__/project-create.test.ts.snap
index 9a99deeb..799e2a6d 100644
--- a/test/commands/project/__snapshots__/project-create.test.ts.snap
+++ b/test/commands/project/__snapshots__/project-create.test.ts.snap
@@ -16,26 +16,29 @@ Description:
 
 Options:
 
-  -h, --help                             - Show this help.                                                             
-  -n, --name              <name>         - Project name (required)                                                     
-  -d, --description       <description>  - Project description (max 255 characters, enforced by Linear's API)          
-  -f, --description-file  <path>         - Read project description from file (still subject to the 255-character API  
-                                           limit)                                                                      
-  --content               <markdown>     - Project overview markdown                                                   
-  --content-file          <path>         - Read project overview markdown from a file                                  
-  -t, --team              <team>         - Team key, name, or ID (required, can be repeated for multiple teams)        
-  -l, --lead              <lead>         - Project lead (username, email, or @me)                                      
-  -s, --status            <status>       - Project status (planned, started, paused, completed, canceled, backlog)     
-  --start-date            <startDate>    - Start date (YYYY-MM-DD)                                                     
-  --target-date           <targetDate>   - Target completion date (YYYY-MM-DD)                                         
-  --priority              <priority>     - Project priority (none, urgent, high, medium, low)                          
-  --label                 <label>        - Project label associated with the project. May be repeated.                 
-  --member                <user>         - Project member (username, email, display name, or @me). May be repeated.    
-  --icon                  <icon>         - Project icon                                                                
-  --color                 <color>        - Project color as a HEX string                                               
-  --initiative            <initiative>   - Add to initiative immediately (ID, slug, or name)                           
-  -i, --interactive                      - Interactive mode (default if no flags provided)                             
-  -j, --json                             - Output created project as JSON                                              
+  -h, --help                             - Show this help.                                                                  
+  -n, --name              <name>         - Project name (required)                                                          
+  -d, --description       <description>  - Project description (max 255 characters, enforced by Linear's API)               
+  -f, --description-file  <path>         - Read project description from file (still subject to the 255-character API       
+                                           limit)                                                                           
+  --content               <markdown>     - Project overview markdown                                                        
+  --content-file          <path>         - Read project overview markdown from a file                                       
+  -t, --team              <team>         - Team key, name, or ID (required, can be repeated for multiple teams)             
+  -l, --lead              <lead>         - Project lead (username, email, or @me)                                           
+  -s, --status            <status>       - Project status (planned, started, paused, completed, canceled, backlog)          
+  --start-date            <startDate>    - Start date (YYYY-MM-DD)                                                          
+  --target-date           <targetDate>   - Target completion date (YYYY-MM-DD)                                              
+  --priority              <priority>     - Project priority (none, urgent, high, medium, low)                               
+  --label                 <label>        - Project label associated with the project. May be repeated.                      
+  --member                <user>         - Project member (username, email, display name, or @me). May be repeated.         
+  --icon                  <icon>         - Project icon                                                                     
+  --color                 <color>        - Project color as a HEX string                                                    
+  --initiative            <initiative>   - Add to initiative immediately (ID, slug, or name)                                
+  --template              <template>     - Project template to apply, by name or ID (workspace templates plus those of the  
+                                           project's teams). The template fills in anything you do not pass; explicit       
+                                           flags override it. Applied on create only.                                       
+  -i, --interactive                      - Interactive mode (default if no flags provided)                                  
+  -j, --json                             - Output created project as JSON                                                   
 
 "
 stderr:
@@ -115,3 +118,13 @@ stdout:
 stderr:
 ""
 `;
+
+snapshot[`Project Create Command - With Template By Name 1`] = `
+stdout:
+"✓ Created project: Mobile launch
+  Slug: mobile-launch
+  URL: https://linear.app/test/project/mobile-launch
+"
+stderr:
+""
+`;
diff --git a/test/commands/project/project-create.test.ts b/test/commands/project/project-create.test.ts
index 8e191a9d..867e5d7e 100644
--- a/test/commands/project/project-create.test.ts
+++ b/test/commands/project/project-create.test.ts
@@ -1,12 +1,15 @@
 import { snapshotTest as cliffySnapshotTest } from "@cliffy/testing"
-import { assertEquals, assertRejects } from "@std/assert"
+import { assertEquals, assertRejects, assertStringIncludes } from "@std/assert"
 import { stub } from "@std/testing/mock"
 import {
   createCommand,
   resolveProjectContent,
 } from "../../../src/commands/project/project-create.ts"
 import { ValidationError } from "../../../src/utils/errors.ts"
-import { commonDenoArgs } from "../../utils/test-helpers.ts"
+import {
+  captureCommandError,
+  commonDenoArgs,
+} from "../../utils/test-helpers.ts"
 import { MockLinearServer } from "../../utils/mock_linear_server.ts"
 
 const descriptionFilePath = await Deno.makeTempFile({ suffix: ".md" })
@@ -628,3 +631,148 @@ await cliffySnapshotTest({
     }
   },
 })
+
+// --template: resolved against the project's teams and sent as templateId.
+const KICKOFF_TEMPLATE_ID = "22222222-2222-4222-8222-222222222222"
+
+const projectTemplatesMock = {
+  queryName: "GetTemplates",
+  response: {
+    data: {
+      templates: [
+        {
+          id: KICKOFF_TEMPLATE_ID,
+          name: "Kickoff",
+          description: null,
+          type: "project",
+          icon: null,
+          color: null,
+          hasFormFields: false,
+          lastAppliedAt: null,
+          sortOrder: 0,
+          createdAt: "2024-01-01T00:00:00.000Z",
+          updatedAt: "2024-01-01T00:00:00.000Z",
+          team: null,
+          inheritedFrom: null,
+          creator: null,
+          templateData: '{"name":"Kickoff: ","priority":3}',
+        },
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          name: "Bug report",
+          description: null,
+          type: "issue",
+          icon: null,
+          color: null,
+          hasFormFields: false,
+          lastAppliedAt: null,
+          sortOrder: 0,
+          createdAt: "2024-01-01T00:00:00.000Z",
+          updatedAt: "2024-01-01T00:00:00.000Z",
+          team: { id: "team-eng-123", key: "ENG", name: "Engineering" },
+          inheritedFrom: null,
+          creator: null,
+          templateData: '{"title":"Bug: "}',
+        },
+      ],
+    },
+  },
+}
+
+await cliffySnapshotTest({
+  name: "Project Create Command - With Template By Name",
+  meta: import.meta,
+  colors: false,
+  args: ["--name", "Mobile launch", "--team", "ENG", "--template", "kickoff"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    const server = new MockLinearServer([
+      {
+        queryName: "ResolveTeam",
+        response: {
+          data: {
+            teams: {
+              nodes: [{ id: "team-eng-123", key: "ENG", name: "Engineering" }],
+            },
+          },
+        },
+      },
+      projectTemplatesMock,
+      {
+        queryName: "CreateProject",
+        // Exact key set: no useDefaultTemplate travels with templateId.
+        variables: {
+          input: {
+            name: "Mobile launch",
+            teamIds: ["team-eng-123"],
+            templateId: KICKOFF_TEMPLATE_ID,
+          },
+        },
+        response: {
+          data: {
+            projectCreate: {
+              success: true,
+              project: {
+                id: "550e8400-e29b-41d4-a716-446655440077",
+                slugId: "mobile-launch",
+                name: "Mobile launch",
+                url: "https://linear.app/test/project/mobile-launch",
+              },
+            },
+          },
+        },
+      },
+    ])
+
+    try {
+      await server.start()
+      Deno.env.set("LINEAR_GRAPHQL_ENDPOINT", server.getEndpoint())
+      Deno.env.set("LINEAR_API_KEY", "Bearer test-token")
+      await createCommand.parse()
+    } finally {
+      await server.stop()
+      Deno.env.delete("LINEAR_GRAPHQL_ENDPOINT")
+      Deno.env.delete("LINEAR_API_KEY")
+    }
+  },
+})
+
+Deno.test("Project Create Command - an issue template is rejected before the mutation", async () => {
+  // No CreateProject mock: reaching the mutation would surface a different error.
+  const server = new MockLinearServer([
+    {
+      queryName: "ResolveTeam",
+      response: {
+        data: {
+          teams: {
+            nodes: [{ id: "team-eng-123", key: "ENG", name: "Engineering" }],
+          },
+        },
+      },
+    },
+    projectTemplatesMock,
+  ])
+  try {
+    await server.start()
+    Deno.env.set("LINEAR_GRAPHQL_ENDPOINT", server.getEndpoint())
+    Deno.env.set("LINEAR_API_KEY", "Bearer test-token")
+    const output = await captureCommandError(() =>
+      createCommand.parse([
+        "--name",
+        "Mobile launch",
+        "--team",
+        "ENG",
+        "--template",
+        "Bug report",
+      ])
+    )
+    assertStringIncludes(
+      output,
+      '✗ Failed to create project: Template "Bug report" is an issue template, not a project template',
+    )
+  } finally {
+    await server.stop()
+    Deno.env.delete("LINEAR_GRAPHQL_ENDPOINT")
+    Deno.env.delete("LINEAR_API_KEY")
+  }
+})
diff --git a/test/commands/template/__snapshots__/template-list.test.ts.snap b/test/commands/template/__snapshots__/template-list.test.ts.snap
new file mode 100644
index 00000000..63a72060
--- /dev/null
+++ b/test/commands/template/__snapshots__/template-list.test.ts.snap
@@ -0,0 +1,224 @@
+export const snapshot = {};
+
+snapshot[`Template List Command - Help Text 1`] = `
+stdout:
+\`
+Usage: list
+
+Description:
+
+  List templates. Without --team, every template in the workspace is shown.
+
+Options:
+
+  -h, --help          - Show this help.                                                                                                       
+  --type      <type>  - Only templates of this type (issue, project, or document)                     (Values: \\x1b[32m"issue"\\x1b[39m, \\x1b[32m"project"\\x1b[39m, \\x1b[32m"document"\\x1b[39m)
+  --team      <team>  - Team key, name, or ID. Shows that team's templates plus workspace templates.                                          
+  -j, --json          - Output as JSON                                                                                                        
+
+\`
+stderr:
+""
+`;
+
+snapshot[`Template List Command - JSON Output 1`] = `
+stdout:
+'[
+  {
+    "id": "tpl-design",
+    "name": "Design doc",
+    "description": "Design doc description",
+    "type": "document",
+    "icon": null,
+    "color": null,
+    "hasFormFields": false,
+    "lastAppliedAt": null,
+    "sortOrder": 0,
+    "createdAt": "2024-01-01T00:00:00.000Z",
+    "updatedAt": "2024-01-02T00:00:00.000Z",
+    "team": {
+      "id": "team-eng-id",
+      "key": "ENG",
+      "name": "Engineering"
+    },
+    "inheritedFrom": null,
+    "creator": {
+      "id": "user-1",
+      "name": "Sam"
+    },
+    "templateData": "{\\\\"title\\\\":\\\\"Untitled\\\\"}"
+  },
+  {
+    "id": "tpl-bug-workspace",
+    "name": "Bug report",
+    "description": "Bug report description",
+    "type": "issue",
+    "icon": null,
+    "color": null,
+    "hasFormFields": false,
+    "lastAppliedAt": null,
+    "sortOrder": 0,
+    "createdAt": "2024-01-01T00:00:00.000Z",
+    "updatedAt": "2024-01-02T00:00:00.000Z",
+    "team": null,
+    "inheritedFrom": null,
+    "creator": {
+      "id": "user-1",
+      "name": "Sam"
+    },
+    "templateData": "{\\\\"title\\\\":\\\\"Untitled\\\\"}"
+  },
+  {
+    "id": "tpl-bug-eng",
+    "name": "Bug report",
+    "description": "Bug report description",
+    "type": "issue",
+    "icon": null,
+    "color": null,
+    "hasFormFields": false,
+    "lastAppliedAt": null,
+    "sortOrder": 0,
+    "createdAt": "2024-01-01T00:00:00.000Z",
+    "updatedAt": "2024-01-02T00:00:00.000Z",
+    "team": {
+      "id": "team-eng-id",
+      "key": "ENG",
+      "name": "Engineering"
+    },
+    "inheritedFrom": null,
+    "creator": {
+      "id": "user-1",
+      "name": "Sam"
+    },
+    "templateData": "{\\\\"title\\\\":\\\\"Bug: \\\\",\\\\"priority\\\\":2,\\\\"labelIds\\\\":[\\\\"label-bug\\\\"]}"
+  },
+  {
+    "id": "tpl-bug-ops",
+    "name": "Bug report",
+    "description": "Bug report description",
+    "type": "issue",
+    "icon": null,
+    "color": null,
+    "hasFormFields": false,
+    "lastAppliedAt": null,
+    "sortOrder": 0,
+    "createdAt": "2024-01-01T00:00:00.000Z",
+    "updatedAt": "2024-01-02T00:00:00.000Z",
+    "team": {
+      "id": "team-ops-id",
+      "key": "OPS",
+      "name": "Operations"
+    },
+    "inheritedFrom": null,
+    "creator": {
+      "id": "user-1",
+      "name": "Sam"
+    },
+    "templateData": "{\\\\"title\\\\":\\\\"Untitled\\\\"}"
+  },
+  {
+    "id": "tpl-intake-eng",
+    "name": "Intake form",
+    "description": "Intake form description",
+    "type": "issue",
+    "icon": null,
+    "color": null,
+    "hasFormFields": true,
+    "lastAppliedAt": null,
+    "sortOrder": 0,
+    "createdAt": "2024-01-01T00:00:00.000Z",
+    "updatedAt": "2024-01-02T00:00:00.000Z",
+    "team": {
+      "id": "team-eng-id",
+      "key": "ENG",
+      "name": "Engineering"
+    },
+    "inheritedFrom": null,
+    "creator": {
+      "id": "user-1",
+      "name": "Sam"
+    },
+    "templateData": "{\\\\"title\\\\":\\\\"Untitled\\\\"}"
+  },
+  {
+    "id": "tpl-kickoff",
+    "name": "Kickoff",
+    "description": "Kickoff description",
+    "type": "project",
+    "icon": null,
+    "color": null,
+    "hasFormFields": false,
+    "lastAppliedAt": null,
+    "sortOrder": 0,
+    "createdAt": "2024-01-01T00:00:00.000Z",
+    "updatedAt": "2024-01-02T00:00:00.000Z",
+    "team": null,
+    "inheritedFrom": null,
+    "creator": {
+      "id": "user-1",
+      "name": "Sam"
+    },
+    "templateData": "{\\\\"name\\\\":\\\\"Kickoff: \\\\",\\\\"priority\\\\":3}"
+  }
+]
+'
+stderr:
+""
+`;
+
+snapshot[`Template List Command - Filter By Type 1`] = `
+stdout:
+"ID                                   NAME        TYPE         TEAM     
+tpl-bug-workspace                    Bug report  issue        Workspace
+tpl-bug-eng                          Bug report  issue        ENG      
+tpl-bug-ops                          Bug report  issue        OPS      
+tpl-intake-eng                       Intake form issue (form) ENG      
+
+4 templates found.
+"
+stderr:
+""
+`;
+
+snapshot[`Template List Command - Filter By Team Keeps Workspace Templates 1`] = `
+stdout:
+"ID                                   NAME        TYPE         TEAM     
+tpl-design                           Design doc  document     ENG      
+tpl-bug-workspace                    Bug report  issue        Workspace
+tpl-bug-eng                          Bug report  issue        ENG      
+tpl-intake-eng                       Intake form issue (form) ENG      
+tpl-kickoff                          Kickoff     project      Workspace
+
+5 templates found.
+"
+stderr:
+""
+`;
+
+snapshot[`Template List Command - Truncates Wide Names By Display Width 1`] = `
+stdout:
+"ID                                   NAME                                                            TYPE     TEAM     
+tpl-narrow                           Short                                                           document Workspace
+tpl-wide                             模板模板模板模板模板模板模板模板模板模板模板模板模板模板模板... document Workspace
+
+2 templates found.
+"
+stderr:
+""
+`;
+
+snapshot[`Template List Command - Empty 1`] = `
+stdout:
+"No templates found.
+"
+stderr:
+""
+`;
+
+snapshot[`Template List Command - Empty JSON Output 1`] = `
+stdout:
+"[]
+"
+stderr:
+""
+`;
diff --git a/test/commands/template/__snapshots__/template-view.test.ts.snap b/test/commands/template/__snapshots__/template-view.test.ts.snap
new file mode 100644
index 00000000..fa41a80b
--- /dev/null
+++ b/test/commands/template/__snapshots__/template-view.test.ts.snap
@@ -0,0 +1,115 @@
+export const snapshot = {};
+
+snapshot[`Template View Command - Help Text 1`] = `
+stdout:
+"
+Usage: view <template>
+
+Description:
+
+  Show a template and what it pre-fills. Pass its name or ID.
+
+Options:
+
+  -h, --help  - Show this help.                                                                 
+  -j, --json  - Output the template as JSON (templateData stays a JSON-encoded string; use \`jq  
+                '.templateData | fromjson'\`)                                                    
+
+"
+stderr:
+""
+`;
+
+snapshot[`Template View Command - By ID Renders The Body 1`] = `
+stdout:
+"Bug report
+Issue template · Team ENG (Engineering)
+ID: 11111111-1111-4111-8111-111111111111
+Description: Standard bug intake
+Created by: Sam
+Updated: 1/2/2024
+
+Pre-fills:
+  title: Bug: 
+  priority: 2 (high)
+  estimate: 3
+  labelIds: label-bug
+  stateId: state-todo
+  subIssueData: 2 items
+    - Write regression test
+        description: Cover the bug with a test
+        labelIds: label-test
+    - Fix it
+  descriptionData:
+    ## Steps to reproduce
+
+    1. 
+
+    ## Expected
+
+    Describe the expected behaviour.
+
+References are IDs. Map them with \`linear team states\`, \`linear label list\`, \`linear user list\`, or \`linear project list\`.
+"
+stderr:
+""
+`;
+
+snapshot[`Template View Command - By Name Shows Every Key 1`] = `
+stdout:
+"Kickoff
+Project template · Workspace
+ID: tpl-kickoff
+Form template: yes (its form is filled in inside Linear; applying it from the CLI creates the entity with the form unanswered)
+Inherited from: Parent kickoff (tpl-parent)
+Updated: 1/2/2024
+
+Pre-fills:
+  name: Kickoff: 
+  content:
+    ## Goals
+
+    ## Milestones
+  labelIds: (none)
+  priority: 3 (medium)
+  custom:
+    flag: true
+    nested:
+      depth: 2
+
+References are IDs. Map them with \`linear team states\`, \`linear label list\`, \`linear user list\`, or \`linear project list\`.
+"
+stderr:
+""
+`;
+
+snapshot[`Template View Command - JSON Output Keeps templateData Encoded 1`] = `
+stdout:
+'{
+  "id": "11111111-1111-4111-8111-111111111111",
+  "name": "Bug report",
+  "description": "Standard bug intake",
+  "type": "issue",
+  "icon": null,
+  "color": null,
+  "hasFormFields": false,
+  "lastAppliedAt": null,
+  "sortOrder": 0,
+  "createdAt": "2024-01-01T12:00:00.000Z",
+  "updatedAt": "2024-01-02T12:00:00.000Z",
+  "team": {
+    "id": "team-eng-id",
+    "key": "ENG",
+    "name": "Engineering"
+  },
+  "inheritedFrom": null,
+  "creator": {
+    "id": "user-1",
+    "name": "Sam"
+  },
+  "templateData": "{\\\\"title\\\\":\\\\"Bug: \\\\",\\\\"priority\\\\":2,\\\\"estimate\\\\":3,\\\\"labelIds\\\\":[\\\\"label-bug\\\\"],\\\\"stateId\\\\":\\\\"state-todo\\\\",\\\\"subIssueData\\\\":[{\\\\"title\\\\":\\\\"Write regression test\\\\",\\\\"description\\\\":\\\\"Cover the bug with a test\\\\",\\\\"labelIds\\\\":[\\\\"label-test\\\\"]},{\\\\"title\\\\":\\\\"Fix it\\\\"}],\\\\"descriptionData\\\\":{\\\\"type\\\\":\\\\"doc\\\\",\\\\"content\\\\":[{\\\\"type\\\\":\\\\"heading\\\\",\\\\"attrs\\\\":{\\\\"level\\\\":2},\\\\"content\\\\":[{\\\\"type\\\\":\\\\"text\\\\",\\\\"text\\\\":\\\\"Steps to reproduce\\\\"}]},{\\\\"type\\\\":\\\\"ordered_list\\\\",\\\\"attrs\\\\":{\\\\"order\\\\":1},\\\\"content\\\\":[{\\\\"type\\\\":\\\\"list_item\\\\",\\\\"content\\\\":[{\\\\"type\\\\":\\\\"paragraph\\\\"}]}]},{\\\\"type\\\\":\\\\"heading\\\\",\\\\"attrs\\\\":{\\\\"level\\\\":2},\\\\"content\\\\":[{\\\\"type\\\\":\\\\"text\\\\",\\\\"text\\\\":\\\\"Expected\\\\"}]},{\\\\"type\\\\":\\\\"paragraph\\\\",\\\\"content\\\\":[{\\\\"type\\\\":\\\\"text\\\\",\\\\"text\\\\":\\\\"Describe the \\\\"},{\\\\"type\\\\":\\\\"text\\\\",\\\\"text\\\\":\\\\"expected\\\\",\\\\"marks\\\\":[{\\\\"type\\\\":\\\\"bold\\\\"}]},{\\\\"type\\\\":\\\\"text\\\\",\\\\"text\\\\":\\\\" behaviour.\\\\"}]}]}}"
+}
+'
+stderr:
+""
+`;
diff --git a/test/commands/template/template-list.test.ts b/test/commands/template/template-list.test.ts
new file mode 100644
index 00000000..a8d1af53
--- /dev/null
+++ b/test/commands/template/template-list.test.ts
@@ -0,0 +1,178 @@
+import { snapshotTest } from "@cliffy/testing"
+import { listCommand } from "../../../src/commands/template/template-list.ts"
+import { MockLinearServer } from "../../utils/mock_linear_server.ts"
+import { assertStringIncludes } from "@std/assert"
+import {
+  captureCommandError,
+  commonDenoArgs,
+  resolveTeamMock,
+} from "../../utils/test-helpers.ts"
+
+const ENG = { id: "team-eng-id", key: "ENG", name: "Engineering" }
+const OPS = { id: "team-ops-id", key: "OPS", name: "Operations" }
+
+function template(
+  id: string,
+  name: string,
+  type: string,
+  team: { id: string; key: string; name: string } | null,
+  extra: { hasFormFields?: boolean; templateData?: string } = {},
+) {
+  return {
+    id,
+    name,
+    description: `${name} description`,
+    type,
+    icon: null,
+    color: null,
+    hasFormFields: extra.hasFormFields ?? false,
+    lastAppliedAt: null,
+    sortOrder: 0,
+    createdAt: "2024-01-01T00:00:00.000Z",
+    updatedAt: "2024-01-02T00:00:00.000Z",
+    team,
+    inheritedFrom: null,
+    creator: { id: "user-1", name: "Sam" },
+    templateData: extra.templateData ?? '{"title":"Untitled"}',
+  }
+}
+
+// Deliberately unsorted: the command orders by type, then name, then scope.
+const TEMPLATES = [
+  template("tpl-kickoff", "Kickoff", "project", null, {
+    templateData: '{"name":"Kickoff: ","priority":3}',
+  }),
+  template("tpl-bug-ops", "Bug report", "issue", OPS),
+  template("tpl-intake-eng", "Intake form", "issue", ENG, {
+    hasFormFields: true,
+  }),
+  template("tpl-design", "Design doc", "document", ENG),
+  template("tpl-bug-eng", "Bug report", "issue", ENG, {
+    templateData: '{"title":"Bug: ","priority":2,"labelIds":["label-bug"]}',
+  }),
+  // Same type and name as the team ones: the workspace template sorts first.
+  template("tpl-bug-workspace", "Bug report", "issue", null),
+]
+
+function templatesMock(templates: unknown[]) {
+  return {
+    queryName: "GetTemplates",
+    response: { data: { templates } },
+  }
+}
+
+async function withServer(
+  mocks: ConstructorParameters<typeof MockLinearServer>[0],
+  run: () => Promise<unknown>,
+) {
+  const server = new MockLinearServer(mocks)
+  try {
+    await server.start()
+    Deno.env.set("LINEAR_GRAPHQL_ENDPOINT", server.getEndpoint())
+    Deno.env.set("LINEAR_API_KEY", "Bearer test-token")
+    await run()
+  } finally {
+    await server.stop()
+    Deno.env.delete("LINEAR_GRAPHQL_ENDPOINT")
+    Deno.env.delete("LINEAR_API_KEY")
+  }
+}
+
+await snapshotTest({
+  name: "Template List Command - Help Text",
+  meta: import.meta,
+  colors: false,
+  args: ["--help"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await listCommand.parse()
+  },
+})
+
+await snapshotTest({
+  name: "Template List Command - JSON Output",
+  meta: import.meta,
+  colors: false,
+  args: ["--json"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await withServer([templatesMock(TEMPLATES)], () => listCommand.parse())
+  },
+})
+
+await snapshotTest({
+  name: "Template List Command - Filter By Type",
+  meta: import.meta,
+  colors: false,
+  args: ["--type", "issue"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await withServer([templatesMock(TEMPLATES)], () => listCommand.parse())
+  },
+})
+
+await snapshotTest({
+  name: "Template List Command - Filter By Team Keeps Workspace Templates",
+  meta: import.meta,
+  colors: false,
+  args: ["--team", "ENG"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await withServer(
+      [resolveTeamMock("ENG", ENG), templatesMock(TEMPLATES)],
+      () => listCommand.parse(),
+    )
+  },
+})
+
+await snapshotTest({
+  name: "Template List Command - Truncates Wide Names By Display Width",
+  meta: import.meta,
+  colors: false,
+  args: ["--type", "document"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    // 60 CJK characters are 120 terminal columns, wider than the NAME column
+    // in a 120-column table; truncation must count columns, not code units.
+    await withServer([
+      templatesMock([
+        template("tpl-wide", "模板".repeat(30), "document", null),
+        template("tpl-narrow", "Short", "document", null),
+      ]),
+    ], () => listCommand.parse())
+  },
+})
+
+await snapshotTest({
+  name: "Template List Command - Empty",
+  meta: import.meta,
+  colors: false,
+  // The only document template belongs to ENG, so OPS sees none.
+  args: ["--type", "document", "--team", "OPS"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await withServer(
+      [resolveTeamMock("OPS", OPS), templatesMock(TEMPLATES)],
+      () => listCommand.parse(),
+    )
+  },
+})
+
+await snapshotTest({
+  name: "Template List Command - Empty JSON Output",
+  meta: import.meta,
+  colors: false,
+  args: ["--json"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await withServer([templatesMock([])], () => listCommand.parse())
+  },
+})
+
+Deno.test("Template List Command - rejects an unknown --type before any request", async () => {
+  const output = await captureCommandError(() =>
+    listCommand.parse(["--type", "bogus"])
+  )
+  assertStringIncludes(output, 'Option "--type"')
+  assertStringIncludes(output, "bogus")
+})
diff --git a/test/commands/template/template-view.test.ts b/test/commands/template/template-view.test.ts
new file mode 100644
index 00000000..cc60dcd9
--- /dev/null
+++ b/test/commands/template/template-view.test.ts
@@ -0,0 +1,242 @@
+import { snapshotTest } from "@cliffy/testing"
+import { viewCommand } from "../../../src/commands/template/template-view.ts"
+import { MockLinearServer } from "../../utils/mock_linear_server.ts"
+import { assertStringIncludes } from "@std/assert"
+import {
+  captureCommandError,
+  commonDenoArgs,
+} from "../../utils/test-helpers.ts"
+
+const ENG = { id: "team-eng-id", key: "ENG", name: "Engineering" }
+const BUG_ID = "11111111-1111-4111-8111-111111111111"
+
+// The body shape Linear stores for an issue template: ProseMirror JSON under
+// descriptionData, never markdown.
+const BUG_TEMPLATE_DATA = JSON.stringify({
+  title: "Bug: ",
+  priority: 2,
+  estimate: 3,
+  labelIds: ["label-bug"],
+  stateId: "state-todo",
+  subIssueData: [
+    {
+      title: "Write regression test",
+      description: "Cover the bug with a test",
+      labelIds: ["label-test"],
+    },
+    { title: "Fix it" },
+  ],
+  descriptionData: {
+    type: "doc",
+    content: [
+      {
+        type: "heading",
+        attrs: { level: 2 },
+        content: [{ type: "text", text: "Steps to reproduce" }],
+      },
+      {
+        type: "ordered_list",
+        attrs: { order: 1 },
+        content: [{ type: "list_item", content: [{ type: "paragraph" }] }],
+      },
+      {
+        type: "heading",
+        attrs: { level: 2 },
+        content: [{ type: "text", text: "Expected" }],
+      },
+      {
+        type: "paragraph",
+        content: [
+          { type: "text", text: "Describe the " },
+          { type: "text", text: "expected", marks: [{ type: "bold" }] },
+          { type: "text", text: " behaviour." },
+        ],
+      },
+    ],
+  },
+})
+
+const BUG_TEMPLATE = {
+  id: BUG_ID,
+  name: "Bug report",
+  description: "Standard bug intake",
+  type: "issue",
+  icon: null,
+  color: null,
+  hasFormFields: false,
+  lastAppliedAt: null,
+  sortOrder: 0,
+  // Noon UTC: formatRelativeTime falls back to toLocaleDateString for old
+  // dates, and a midnight timestamp lands on a different calendar day in CI
+  // (UTC) than on a Pacific-time machine.
+  createdAt: "2024-01-01T12:00:00.000Z",
+  updatedAt: "2024-01-02T12:00:00.000Z",
+  team: ENG,
+  inheritedFrom: null,
+  creator: { id: "user-1", name: "Sam" },
+  templateData: BUG_TEMPLATE_DATA,
+}
+
+const KICKOFF_TEMPLATE = {
+  id: "tpl-kickoff",
+  name: "Kickoff",
+  description: null,
+  type: "project",
+  icon: null,
+  color: null,
+  hasFormFields: true,
+  lastAppliedAt: null,
+  sortOrder: 0,
+  createdAt: "2024-01-01T12:00:00.000Z",
+  updatedAt: "2024-01-02T12:00:00.000Z",
+  team: null,
+  inheritedFrom: { id: "tpl-parent", name: "Parent kickoff" },
+  creator: null,
+  templateData: JSON.stringify({
+    name: "Kickoff: ",
+    content: "## Goals\n\n## Milestones\n",
+    labelIds: [],
+    priority: 3,
+    custom: { flag: true, nested: { depth: 2 } },
+  }),
+}
+
+const BROKEN_TEMPLATE = {
+  ...KICKOFF_TEMPLATE,
+  id: "tpl-broken",
+  name: "Broken",
+  templateData: "[1, 2]",
+}
+
+async function withServer<T>(
+  mocks: ConstructorParameters<typeof MockLinearServer>[0],
+  run: () => Promise<T>,
+): Promise<T> {
+  const server = new MockLinearServer(mocks)
+  try {
+    await server.start()
+    Deno.env.set("LINEAR_GRAPHQL_ENDPOINT", server.getEndpoint())
+    Deno.env.set("LINEAR_API_KEY", "Bearer test-token")
+    return await run()
+  } finally {
+    await server.stop()
+    Deno.env.delete("LINEAR_GRAPHQL_ENDPOINT")
+    Deno.env.delete("LINEAR_API_KEY")
+  }
+}
+
+const listMock = {
+  queryName: "GetTemplates",
+  response: {
+    data: { templates: [BUG_TEMPLATE, KICKOFF_TEMPLATE, BROKEN_TEMPLATE] },
+  },
+}
+
+await snapshotTest({
+  name: "Template View Command - Help Text",
+  meta: import.meta,
+  colors: false,
+  args: ["--help"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await viewCommand.parse()
+  },
+})
+
+await snapshotTest({
+  name: "Template View Command - By ID Renders The Body",
+  meta: import.meta,
+  colors: false,
+  args: [BUG_ID],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await withServer([
+      {
+        queryName: "GetTemplate",
+        variables: { id: BUG_ID },
+        response: { data: { template: BUG_TEMPLATE } },
+      },
+    ], () => viewCommand.parse())
+  },
+})
+
+await snapshotTest({
+  name: "Template View Command - By Name Shows Every Key",
+  meta: import.meta,
+  colors: false,
+  args: ["kickoff"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await withServer([listMock], () => viewCommand.parse())
+  },
+})
+
+await snapshotTest({
+  name: "Template View Command - JSON Output Keeps templateData Encoded",
+  meta: import.meta,
+  colors: false,
+  args: [BUG_ID, "--json"],
+  denoArgs: commonDenoArgs,
+  async fn() {
+    await withServer([
+      {
+        queryName: "GetTemplate",
+        variables: { id: BUG_ID },
+        response: { data: { template: BUG_TEMPLATE } },
+      },
+    ], () => viewCommand.parse())
+  },
+})
+
+Deno.test("Template View Command - unknown name lists the available templates", async () => {
+  const output = await withServer(
+    [listMock],
+    () => captureCommandError(() => viewCommand.parse(["Nope"])),
+  )
+  assertStringIncludes(
+    output,
+    "✗ Failed to view template: Template not found: Nope",
+  )
+  assertStringIncludes(
+    output,
+    'Available templates: "Broken", "Bug report", "Kickoff". Run `linear template list` to see every template.',
+  )
+})
+
+Deno.test("Template View Command - ambiguous name asks for an ID", async () => {
+  const output = await withServer(
+    [
+      {
+        queryName: "GetTemplates",
+        response: {
+          data: {
+            templates: [
+              BUG_TEMPLATE,
+              { ...BUG_TEMPLATE, id: "tpl-bug-workspace", team: null },
+            ],
+          },
+        },
+      },
+    ],
+    () => captureCommandError(() => viewCommand.parse(["bug REPORT"])),
+  )
+  assertStringIncludes(
+    output,
+    'Template name "bug REPORT" is ambiguous: it matches 2 templates',
+  )
+  assertStringIncludes(
+    output,
+    `Pass the template ID instead: ${BUG_ID} (issue, ENG), tpl-bug-workspace (issue, Workspace)`,
+  )
+})
+
+Deno.test("Template View Command - malformed templateData is reported, not hidden", async () => {
+  const output = await withServer(
+    [listMock],
+    () => captureCommandError(() => viewCommand.parse(["Broken"])),
+  )
+  assertStringIncludes(
+    output,
+    '✗ Failed to view template: Template data for "Broken" (tpl-broken) is not a JSON object',
+  )
+})
diff --git a/test/utils/prosemirror.test.ts b/test/utils/prosemirror.test.ts
new file mode 100644
index 00000000..d6996ae9
--- /dev/null
+++ b/test/utils/prosemirror.test.ts
@@ -0,0 +1,189 @@
+import { assertEquals, assertThrows } from "@std/assert"
+import { proseMirrorToMarkdown } from "../../src/utils/prosemirror.ts"
+import { ValidationError } from "../../src/utils/errors.ts"
+
+function text(value: string, marks?: { type: string; attrs?: unknown }[]) {
+  return marks == null ? { type: "text", text: value } : {
+    type: "text",
+    text: value,
+    marks,
+  }
+}
+
+function paragraph(...content: unknown[]) {
+  return { type: "paragraph", content }
+}
+
+Deno.test("proseMirrorToMarkdown renders the body Linear stores for an issue template", () => {
+  // The exact shape Linear returned for a template created with a markdown
+  // description: headings, an ordered list with an empty item, headings.
+  const doc = {
+    type: "doc",
+    content: [
+      {
+        type: "heading",
+        attrs: { level: 2, id: "f0ba1592" },
+        content: [text("Steps to reproduce")],
+      },
+      {
+        type: "ordered_list",
+        attrs: { order: 1 },
+        content: [{ type: "list_item", content: [{ type: "paragraph" }] }],
+      },
+      { type: "heading", attrs: { level: 2 }, content: [text("Expected")] },
+      { type: "heading", attrs: { level: 2 }, content: [text("Actual")] },
+    ],
+  }
+  assertEquals(
+    proseMirrorToMarkdown(doc),
+    "## Steps to reproduce\n\n1. \n\n## Expected\n\n## Actual",
+  )
+})
+
+Deno.test("proseMirrorToMarkdown renders marks, links, and hard breaks", () => {
+  const doc = {
+    type: "doc",
+    content: [
+      paragraph(
+        text("Hello "),
+        text("world", [{ type: "bold" }]),
+        text(" and "),
+        text("code", [{ type: "code" }]),
+        text(" "),
+        text("link", [{
+          type: "link",
+          attrs: { href: "https://example.com" },
+        }]),
+        { type: "hard_break" },
+        text("next", [{ type: "em" }, { type: "strike" }]),
+      ),
+    ],
+  }
+  assertEquals(
+    proseMirrorToMarkdown(doc),
+    "Hello **world** and `code` [link](https://example.com)\n~~_next_~~",
+  )
+})
+
+Deno.test("proseMirrorToMarkdown renders nested lists, todo lists, code, and quotes", () => {
+  const doc = {
+    type: "doc",
+    content: [
+      {
+        type: "bullet_list",
+        content: [
+          {
+            type: "list_item",
+            content: [
+              paragraph(text("one")),
+              {
+                type: "bullet_list",
+                content: [
+                  { type: "list_item", content: [paragraph(text("nested"))] },
+                ],
+              },
+            ],
+          },
+          { type: "list_item", content: [paragraph(text("two"))] },
+        ],
+      },
+      {
+        type: "todo_list",
+        content: [
+          {
+            type: "todo_item",
+            attrs: { done: true },
+            content: [paragraph(text("done"))],
+          },
+          { type: "todo_item", content: [paragraph(text("open"))] },
+        ],
+      },
+      {
+        type: "code_block",
+        attrs: { language: "ts" },
+        content: [text("const a = 1")],
+      },
+      { type: "blockquote", content: [paragraph(text("quoted"))] },
+      { type: "horizontal_rule" },
+    ],
+  }
+  assertEquals(
+    proseMirrorToMarkdown(doc),
+    [
+      "- one\n\n  - nested\n- two",
+      "- [x] done\n- [ ] open",
+      "```ts\nconst a = 1\n```",
+      "> quoted",
+      "---",
+    ].join("\n\n"),
+  )
+})
+
+Deno.test("proseMirrorToMarkdown keeps unknown nodes visible instead of dropping them", () => {
+  const doc = {
+    type: "doc",
+    content: [
+      paragraph(
+        text("cc "),
+        { type: "suggestion_userMentions", attrs: { id: "u1", label: "@sam" } },
+        text(" and "),
+        { type: "mystery_inline" },
+      ),
+      { type: "embed", attrs: { url: "https://example.com" } },
+      { type: "wrapper", content: [paragraph(text("inside a wrapper"))] },
+    ],
+  }
+  assertEquals(
+    proseMirrorToMarkdown(doc),
+    "cc @sam and [mystery_inline]\n\n[unsupported embed node]\n\ninside a wrapper",
+  )
+})
+
+Deno.test("proseMirrorToMarkdown escapes literal Markdown punctuation but not code", () => {
+  const doc = {
+    type: "doc",
+    content: [
+      paragraph(
+        text("*literal* `tick` [x] a_b # 1 > 2 "),
+        text("a ` b", [{ type: "code" }]),
+        text(" "),
+        text("*bold*", [{ type: "bold" }]),
+      ),
+      paragraph(text("- not a list")),
+      paragraph(text("1. not ordered")),
+      paragraph(text("2026 roadmap")),
+      {
+        type: "code_block",
+        content: [text("```md\nfenced inside\n```")],
+      },
+    ],
+  }
+  assertEquals(
+    proseMirrorToMarkdown(doc),
+    [
+      "\\*literal\\* \\`tick\\` \\[x\\] a\\_b \\# 1 \\> 2 `` a ` b `` **\\*bold\\***",
+      "\\- not a list",
+      "1\\. not ordered",
+      "2026 roadmap",
+      "````\n```md\nfenced inside\n```\n````",
+    ].join("\n\n"),
+  )
+})
+
+Deno.test("proseMirrorToMarkdown rejects values that are not a document", () => {
+  assertThrows(
+    () => proseMirrorToMarkdown({ type: "paragraph", content: [] }),
+    ValidationError,
+    'Expected a ProseMirror document, got a "paragraph" node',
+  )
+  assertThrows(
+    () => proseMirrorToMarkdown({ type: "doc", content: "not an array" }),
+    ValidationError,
+    '"content" must be an array',
+  )
+  assertThrows(
+    () => proseMirrorToMarkdown("## markdown"),
+    ValidationError,
+    "Invalid ProseMirror node at doc",
+  )
+})
diff --git a/test/utils/templates.test.ts b/test/utils/templates.test.ts
new file mode 100644
index 00000000..f36319b1
--- /dev/null
+++ b/test/utils/templates.test.ts
@@ -0,0 +1,294 @@
+import { assertEquals, assertRejects } from "@std/assert"
+import {
+  parseTemplateData,
+  resolveTemplate,
+} from "../../src/utils/templates.ts"
+import {
+  CliError,
+  NotFoundError,
+  ValidationError,
+} from "../../src/utils/errors.ts"
+import { setupMockLinearServer } from "./test-helpers.ts"
+
+const ENG = { id: "team-eng-id", key: "ENG", name: "Engineering" }
+const OPS = { id: "team-ops-id", key: "OPS", name: "Operations" }
+
+function template(
+  id: string,
+  name: string,
+  type: string,
+  team: { id: string; key: string; name: string } | null,
+) {
+  return {
+    id,
+    name,
+    description: null,
+    type,
+    icon: null,
+    color: null,
+    hasFormFields: false,
+    lastAppliedAt: null,
+    sortOrder: 0,
+    createdAt: "2024-01-01T00:00:00.000Z",
+    updatedAt: "2024-01-01T00:00:00.000Z",
+    team,
+    inheritedFrom: null,
+    creator: null,
+    templateData: "{}",
+  }
+}
+
+const BUG_ENG = "11111111-1111-4111-8111-111111111111"
+const BUG_OPS = "22222222-2222-4222-8222-222222222222"
+const BUG_WORKSPACE = "33333333-3333-4333-8333-333333333333"
+const FEATURE_ENG = "44444444-4444-4444-8444-444444444444"
+const FEATURE_OPS = "55555555-5555-4555-8555-555555555555"
+const KICKOFF = "66666666-6666-4666-8666-666666666666"
+const ROADMAP_OPS = "77777777-7777-4777-8777-777777777777"
+const DESIGN_ENG = "88888888-8888-4888-8888-888888888888"
+const RETRO_WORKSPACE_PROJECT = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
+const RETRO_OPS_ISSUE = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"
+const MISSING = "99999999-9999-4999-8999-999999999999"
+
+const TEMPLATES = [
+  template(BUG_ENG, "Bug report", "issue", ENG),
+  template(BUG_OPS, "Bug report", "issue", OPS),
+  template(BUG_WORKSPACE, "Bug report", "issue", null),
+  template(FEATURE_ENG, "Feature request", "issue", ENG),
+  template(FEATURE_OPS, "Feature request", "issue", OPS),
+  template(KICKOFF, "Kickoff", "project", null),
+  template(ROADMAP_OPS, "Roadmap", "project", OPS),
+  template(DESIGN_ENG, "Design doc", "document", ENG),
+  // Same name, excluded for different reasons: the API order must not decide
+  // which reason is reported.
+  template(RETRO_WORKSPACE_PROJECT, "Retro", "project", null),
+  template(RETRO_OPS_ISSUE, "Retro", "issue", OPS),
+]
+
+Deno.test("resolveTemplate", async (t) => {
+  const { cleanup } = await setupMockLinearServer([
+    {
+      queryName: "GetTemplates",
+      response: { data: { templates: TEMPLATES } },
+    },
+    ...TEMPLATES.map((entry) => ({
+      queryName: "GetTemplate",
+      variables: { id: entry.id },
+      response: { data: { template: entry } },
+    })),
+    {
+      queryName: "GetTemplate",
+      variables: { id: MISSING },
+      response: {
+        errors: [{
+          message: `No template found with id ${MISSING}`,
+          path: ["template"],
+        }],
+        data: null,
+      },
+    },
+  ])
+
+  try {
+    await t.step(
+      "matches a name case-insensitively and filters by scope before judging ambiguity",
+      async () => {
+        const resolved = await resolveTemplate("feature REQUEST", {
+          type: "issue",
+          teamIds: [ENG.id],
+        })
+        assertEquals(resolved.id, FEATURE_ENG)
+      },
+    )
+
+    await t.step(
+      "a name that is still ambiguous within scope errors with the IDs",
+      async () => {
+        const error = await assertRejects(
+          () =>
+            resolveTemplate("Bug report", { type: "issue", teamIds: [ENG.id] }),
+          ValidationError,
+          'Template name "Bug report" is ambiguous: it matches 2 templates',
+        )
+        assertEquals(
+          error.suggestion,
+          `Pass the template ID instead: ${BUG_ENG} (issue, ENG), ${BUG_WORKSPACE} (issue, Workspace)`,
+        )
+      },
+    )
+
+    await t.step(
+      "without a scope every same-named template counts",
+      async () => {
+        await assertRejects(
+          () => resolveTemplate("Feature request"),
+          ValidationError,
+          "matches 2 templates",
+        )
+      },
+    )
+
+    await t.step("a workspace template is available to any team", async () => {
+      const resolved = await resolveTemplate("Kickoff", {
+        type: "project",
+        teamIds: [ENG.id],
+      })
+      assertEquals(resolved.id, KICKOFF)
+    })
+
+    await t.step(
+      "a team template is available when any of the scope's teams owns it",
+      async () => {
+        const resolved = await resolveTemplate("Roadmap", {
+          type: "project",
+          teamIds: [ENG.id, OPS.id],
+        })
+        assertEquals(resolved.id, ROADMAP_OPS)
+      },
+    )
+
+    await t.step("a name of the wrong type says which type it is", async () => {
+      const error = await assertRejects(
+        () => resolveTemplate("Kickoff", { type: "issue", teamIds: [ENG.id] }),
+        ValidationError,
+        'Template "Kickoff" is a project template, not an issue template',
+      )
+      assertEquals(
+        error.suggestion,
+        "Run `linear template list --type issue` to see the issue templates.",
+      )
+    })
+
+    await t.step(
+      "a name owned by another team says which team owns it",
+      async () => {
+        await assertRejects(
+          () =>
+            resolveTemplate("Roadmap", { type: "project", teamIds: [ENG.id] }),
+          ValidationError,
+          'Template "Roadmap" belongs to team OPS and cannot be applied here',
+        )
+      },
+    )
+
+    await t.step(
+      "when same-named templates miss for different reasons, the team mismatch is reported",
+      async () => {
+        await assertRejects(
+          () => resolveTemplate("Retro", { type: "issue", teamIds: [ENG.id] }),
+          ValidationError,
+          'Template "Retro" belongs to team OPS and cannot be applied here',
+        )
+        await assertRejects(
+          () =>
+            resolveTemplate("Retro", { type: "document", teamIds: [ENG.id] }),
+          ValidationError,
+          'Template "Retro" is a project template, not a document template',
+        )
+      },
+    )
+
+    await t.step(
+      "an unknown name lists the names that would have qualified",
+      async () => {
+        const error = await assertRejects(
+          () => resolveTemplate("Nope", { type: "issue", teamIds: [OPS.id] }),
+          NotFoundError,
+          "Template not found: Nope",
+        )
+        assertEquals(
+          error.suggestion,
+          'Available issue templates: "Bug report", "Feature request", "Retro". Run `linear template list` to see every template.',
+        )
+      },
+    )
+
+    await t.step("an unknown name with nothing in scope says so", async () => {
+      const error = await assertRejects(
+        () => resolveTemplate("Nope", { type: "document", teamIds: [OPS.id] }),
+        NotFoundError,
+      )
+      assertEquals(
+        error.suggestion,
+        "No document templates are available here. Run `linear template list` to see every template.",
+      )
+    })
+
+    await t.step(
+      "a UUID is fetched directly and checked against the scope",
+      async () => {
+        const resolved = await resolveTemplate(FEATURE_OPS, {
+          type: "issue",
+          teamIds: [OPS.id],
+        })
+        assertEquals(resolved.name, "Feature request")
+        await assertRejects(
+          () =>
+            resolveTemplate(FEATURE_OPS, { type: "issue", teamIds: [ENG.id] }),
+          ValidationError,
+          "belongs to team OPS",
+        )
+        await assertRejects(
+          () =>
+            resolveTemplate(DESIGN_ENG, { type: "issue", teamIds: [ENG.id] }),
+          ValidationError,
+          "is a document template, not an issue template",
+        )
+      },
+    )
+
+    await t.step("a missing UUID becomes a not-found error", async () => {
+      await assertRejects(
+        () => resolveTemplate(MISSING),
+        NotFoundError,
+        `Template not found: ${MISSING}`,
+      )
+    })
+  } finally {
+    await cleanup()
+  }
+})
+
+Deno.test("parseTemplateData decodes the JSON-encoded string and rejects other shapes", () => {
+  const base = { id: "tpl", name: "Bug report" }
+  assertEquals(
+    parseTemplateData({
+      ...base,
+      templateData: '{"title":"Bug: ","priority":2}',
+    }),
+    { title: "Bug: ", priority: 2 },
+  )
+  assertEquals(
+    parseTemplateData({ ...base, templateData: { title: "already decoded" } }),
+    { title: "already decoded" },
+  )
+  assertRejectsSync(
+    () => parseTemplateData({ ...base, templateData: "not json" }),
+    "is not valid JSON",
+  )
+  assertRejectsSync(
+    () => parseTemplateData({ ...base, templateData: "[1,2]" }),
+    "is not a JSON object",
+  )
+  assertRejectsSync(
+    () => parseTemplateData({ ...base, templateData: 42 }),
+    "is not a JSON object",
+  )
+})
+
+function assertRejectsSync(fn: () => unknown, messageIncludes: string) {
+  let caught: unknown
+  try {
+    fn()
+  } catch (error) {
+    caught = error
+  }
+  if (!(caught instanceof CliError)) {
+    throw new Error(`Expected a CliError, got ${String(caught)}`)
+  }
+  if (!caught.userMessage.includes(messageIncludes)) {
+    throw new Error(
+      `Expected "${caught.userMessage}" to include "${messageIncludes}"`,
+    )
+  }
+}
diff --git a/test/utils/test-helpers.ts b/test/utils/test-helpers.ts
index 9e2f3201..2839760a 100644
--- a/test/utils/test-helpers.ts
+++ b/test/utils/test-helpers.ts
@@ -1,3 +1,4 @@
+import { stub } from "@std/testing/mock"
 import { MockLinearServer } from "./mock_linear_server.ts"
 
 // Common Deno args for permissions used across all tests
@@ -59,3 +60,38 @@ export function resolveTeamMock(
     response: { data: { teams: { nodes: [team] } } },
   }
 }
+
+/**
+ * Run a command that is expected to fail through `handleError`, which calls
+ * `Deno.exit(1)`. The exit is stubbed to throw so the test process survives.
+ * Returns everything the command wrote to `console.error`, joined by newlines,
+ * and throws when the command did not exit.
+ */
+export async function captureCommandError(
+  run: () => Promise<unknown>,
+): Promise<string> {
+  const errorLogs: string[] = []
+  const errorStub = stub(console, "error", (...args: unknown[]) => {
+    errorLogs.push(args.map(String).join(" "))
+  })
+  const exitStub = stub(Deno, "exit", (_code?: number): never => {
+    throw new Error("EXIT")
+  })
+  let exited = false
+  try {
+    await run()
+  } catch (error) {
+    if (error instanceof Error && error.message === "EXIT") {
+      exited = true
+    } else {
+      throw error
+    }
+  } finally {
+    errorStub.restore()
+    exitStub.restore()
+  }
+  if (!exited) {
+    throw new Error("Expected the command to exit with an error")
+  }
+  return errorLogs.join("\n")
+}