===============
LIBRARY RULES
===============
From library maintainers:
- Use TypeScript with ES modules (type: module)
- CLI commands are defined in bin/ and scripts/ directories
- Claude Code plugin commands are in commands/ directory as .md files
- Skills for Claude Code are in skills/ directory
- TOON format files (.toon) are used for configuration and cycle data
- Requires LINEAR_API_KEY environment variable
- Supports both remote (immediate sync) and local (offline-first) modes

### Example: Starting Daily Work with TTT

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

This example illustrates the typical workflow for starting a new day's work using TTT. It includes syncing tasks, selecting the next task, checking out a new Git branch, and starting development.

```bash
ttt sync                    # Get latest Todo/In Progress issues	tt work-on next           # Auto-select highest priority
# Read task details displayed
git checkout -b feature/mp-624-new-feature
# Start coding...
```

--------------------------------

### Install and Initialize team-toon-tack (bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Installs the team-toon-tack CLI globally and sets up the necessary Linear API key. It then initializes the ttt configuration in the current project directory, guiding the user through setup for development teams, testing statuses, QA teams, completion modes, and sync status.

```bash
npm install -g team-toon-tack
export LINEAR_API_KEY="lin_api_xxxxx"

cd your-project
ttt init
```

--------------------------------

### Starting a Work Session Workflow with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Guides through the initial steps of a work session. It involves syncing the latest issues from Linear and then selecting a task to work on, either interactively or automatically.

```bash
# Sync latest issues from Linear (Todo/In Progress only)
ttt sync

# Pick a task to work on (interactive or auto-select)
ttt work-on next
# or
ttt work-on MP-624
```

--------------------------------

### Example: Completing a Task and Moving On with TTT

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

This example shows the process of completing a task, committing code changes, marking the task as done in TTT, and then moving to the next prioritized task.

```bash
git add . && git commit -m "feat: add new feature"	tt done -m "Added feature with tests"	tt work-on next           # Move to next task
```

--------------------------------

### Example: Finding Your Assigned Tasks with TTT

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

This example shows how to use TTT to find issues assigned to you. It covers displaying all your issues, filtering for only those currently in progress, and exporting your issues as Markdown.

```bash
ttt show --user me                          # All my issues	tt show --user me --status "In Progress"   # My in-progress issues	tt show --user me --export                 # Export my issues as markdown
```

--------------------------------

### Example TTT Status Commands

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:status.md

Provides practical examples of using the TTT CLI for common status modifications. These examples cover moving to the next status, marking a task as blocked, and resetting the current task's status.

```bash
ttt status MP-624 --set +1
ttt status MP-624 --set blocked
ttt status --set pending
```

--------------------------------

### Initialize ttt Configuration

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Sets up the ttt CLI by fetching Linear workspace data and creating local configuration files. Supports interactive setup with an API key or non-interactive setup with pre-selected options. The `--force` flag can be used to overwrite existing configurations.

```bash
export LINEAR_API_KEY="lin_api_xxxxxxxxxxxxx"
cd ~/my-project
ttt init

ttt init --user alice@example.com --label Frontend --yes

ttt init --force
```

--------------------------------

### Example: Checking a Specific Issue with TTT

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

This example demonstrates how to view details of a specific issue (MP-624) using TTT. It shows how to check the local data, fetch directly from Linear, and export the issue details as Markdown.

```bash
ttt show MP-624            # Show from local data	tt show MP-624 --remote   # Fetch from Linear	tt show MP-624 --export   # Export as markdown
```

--------------------------------

### Start Working on a Linear Task with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Initiates work on a Linear task. Supports interactive selection from available tasks, auto-selecting the highest priority unassigned task ('next'), or starting on a specific issue.

```bash
ttt work-on           # Interactive selection from available tasks
ttt work-on next      # Auto-select highest priority unassigned task
ttt work-on MP-624    # Start working on specific issue
```

--------------------------------

### Install Claude Code Plugin (bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Installs the team-toon-tack plugin within the Claude Code environment, enabling direct interaction with ttt commands through the chat interface. This allows for seamless integration of Linear issue management into the coding workflow.

```bash
/plugin marketplace add wayne930242/team-toon-tack
/plugin install team-toon-tack@wayne930242
```

--------------------------------

### Start Working on a Task with ttt

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Marks a task as in-progress, either locally or in Linear. Supports interactive selection, auto-selection of the highest priority task (using `next`), or direct specification of an issue ID.

```bash
# Interactive task selection from pending tasks
ttt work-on

# Work on specific issue by ID
ttt work-on MP-624

# Auto-select highest priority task
ttt work-on next
```

--------------------------------

### Work On Task (ttt CLI)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Starts working on a specified Linear issue or automatically selects the highest priority unassigned task. Supports interactive selection for cases where the target task is ambiguous.

```bash
ttt work-on              # Interactive selection
ttt work-on MP-123       # Specific issue
ttt work-on next         # Auto-select highest priority
```

--------------------------------

### Run TTT Sync Command (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:sync.md

This command initiates the synchronization process for TTT issues. It can be run without arguments for a default sync, with a specific issue ID, or with the --update flag to push local changes to Linear. This script assumes the 'ttt' command-line tool is installed and configured.

```bash
ttt sync
ttt sync {{ issue-id }}
ttt sync --update
```

--------------------------------

### Starting Work on a Specific Linear Task using ttt work-on

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:work-on.md

Starts working on a specific Linear task by providing its issue ID as an argument to the 'ttt work-on' command. This allows direct selection of a task for development.

```bash
ttt work-on {{ issue-id }}
```

--------------------------------

### Show Task Status with TTT CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:status.md

Demonstrates how to use the TTT CLI to display the status of the current in-progress task or a specific issue by providing its ID. No external dependencies are required beyond the TTT CLI installation.

```bash
ttt status
ttt status {{ issue-id }}
```

--------------------------------

### Initialize Configuration (ttt CLI)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Initializes the team-toon-tack configuration. Supports interactive mode, pre-selecting a user, setting a default label, or forcing an overwrite of existing configuration files.

```bash
ttt init                           # Interactive mode
ttt init --user alice@example.com  # Pre-select user
ttt init --label Frontend          # Set default label
ttt init --force                   # Overwrite existing config
```

--------------------------------

### Show All Issues (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:show.md

Executes the 'ttt show' command without any arguments to display all issues present in the local cycle data. This is the default behavior and requires no specific parameters.

```bash
ttt show
```

--------------------------------

### Configure Settings (ttt CLI)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Manages team-toon-tack settings. Users can view the current configuration, or specifically configure status mappings, label/user filters, and multi-team selections.

```bash
ttt config              # Show current configuration
ttt config status       # Configure status mappings
ttt config filters      # Configure label/user filters
ttt config teams        # Configure multi-team selection
```

--------------------------------

### Configure CLI Settings Interactively

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Provides an interactive interface for managing various CLI settings, including status mappings for workflow states, label and user filters, and multi-team selection. This helps customize the CLI's behavior to specific project workflows.

```bash
# Show current configuration
ttt config

# Configure status mappings for workflow states
ttt config status

# Configure label and user filters
ttt config filters

# Configure multi-team selection
ttt config teams
```

--------------------------------

### Sync Issues (ttt CLI)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Synchronizes issues from Linear. Options include a fast sync of 'Todo' and 'In Progress' issues, syncing all issues regardless of status, syncing a specific issue by ID, or pushing local status changes to Linear for offline mode.

```bash
ttt sync              # Sync Todo/In Progress issues (fast)
ttt sync --all        # Sync all issues regardless of status
ttt sync MP-123       # Sync specific issue only
ttt sync --update     # Push local status changes to Linear (for local mode)
```

--------------------------------

### Daily Workflow Commands (bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Provides essential commands for daily interaction with team-toon-tack, both within Claude Code using the plugin and directly via the CLI. These commands facilitate syncing issues, picking the next task, and marking tasks as completed with optional messages.

```bash
# In Claude Code:
/ttt:sync              # Fetch all Linear issues for current cycle
/ttt:work-on next      # Pick highest priority task & start working
/ttt:done              # Complete task with AI-generated summary

# Using CLI directly:
ttt sync
ttt work-on next
ttt done -m "Completed the task"
```

--------------------------------

### Syncing Changes Workflow with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Details how to synchronize changes with Linear using the ttt CLI. Covers pulling the latest issues (fast or all) and pushing local status updates to Linear.

```bash
# Pull latest from Linear (fast - only Todo/In Progress)
ttt sync

# Pull ALL issues including completed ones
ttt sync --all

# Push local status changes to Linear (if using local mode)
ttt sync --update
```

--------------------------------

### Show Issue Details (ttt CLI)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Retrieves and displays details for Linear issues. It can show all issues in the local cycle data, a specific issue from local data, or fetch a specific issue directly from Linear. Filtering by labels, status, user, or priority is supported, along with exporting data to markdown format.

```bash
ttt show                       # Show all issues in local cycle data
ttt show MP-123                # Show specific issue from local data
ttt show MP-123 --remote       # Fetch specific issue from Linear
ttt show --label frontend      # Filter by label
ttt show --status "In Progress" --user me   # My in-progress issues
ttt show --priority 1          # Show urgent issues
ttt show --export              # Export as markdown
```

--------------------------------

### Sync Linear Issues with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Syncs issues from Linear to a local 'cycle.toon' file. Supports syncing only Todo/In Progress issues (fast, default), all issues (--all), specific issues, or pushing local changes before syncing (--update).

```bash
ttt sync              # Sync Todo/In Progress issues only (fast, recommended)
ttt sync --all        # Sync ALL issues regardless of status (slower)
ttt sync MP-624       # Sync specific issue only
ttt sync --update     # Push local status changes to Linear first, then sync
```

--------------------------------

### Export Issues as Markdown (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:show.md

Outputs the issue details in markdown format. This option is useful for generating reports or documentation. It can be used on its own or when displaying specific issues or filtered results.

```bash
ttt show --export
```

```bash
ttt show {{ issue-id }} --export
```

--------------------------------

### Troubleshooting Linear API Key Configuration

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

This snippet demonstrates how to set the LINEAR_API_KEY environment variable, which is essential for TTT operations that interact with the Linear API. Ensure this key is set in your terminal session before running TTT commands that require it.

```bash
export LINEAR_API_KEY="lin_api_xxxxx"
```

--------------------------------

### Complete Task (ttt CLI)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Marks a Linear task as completed. It can automatically select the current in-progress task if only one exists, or a specific task can be provided. A custom completion message can be included using the `-m` flag.

```bash
ttt done                    # Auto-select if only one in-progress
ttt done MP-123             # Specific issue
ttt done -m "Fixed the bug" # With completion message
```

--------------------------------

### Development Workflow with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Outlines common actions during development using the ttt CLI. This includes checking task status, viewing issue details, searching issues with filters, exporting issues to markdown, and marking tasks as blocked.

```bash
# Check current task status
ttt status

# Show issue details from local data
ttt show MP-624

# Search issues by filters
ttt show --status "In Progress" --user me

# Export issues as markdown (useful for context)
ttt show --export

# Mark task as blocked if waiting on dependency
ttt status MP-624 --set blocked
```

--------------------------------

### Linear Client Integration with Team Filtering (TypeScript)

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Integrates directly with the Linear SDK to query custom tasks, update statuses, and manage workflow states within specific teams. Requires LINEAR_API_KEY environment variable for client initialization. Fetches issues based on team ID, state, and assignee, and updates their status.

```typescript
import { getLinearClient, loadConfig, loadLocalConfig, getTeamId } from 'team-toon-tack';
import { updateIssueStatus, getWorkflowStates } from 'team-toon-tack/lib/linear';

async function customLinearIntegration() {
  // Initialize client with API key from environment
  const client = getLinearClient(); // Requires LINEAR_API_KEY env var
  const config = await loadConfig();
  const localConfig = await loadLocalConfig();

  // Get team ID from config
  const teamId = getTeamId(config, localConfig.team);

  // Fetch custom issue query
  const issues = await client.issues({
    filter: { 
      team: { id: { eq: teamId } }, 
      state: { name: { in: ['In Progress', 'Todo'] } }, 
      assignee: { email: { eq: 'alice@example.com' } } 
    },
    first: 20
  });

  // Get workflow states for team
  const states = await getWorkflowStates(config, localConfig.team);
  console.log('Available states:', states.map(s => `${s.name} (${s.type})`));

  // Update issue status
  const issue = issues.nodes[0];
  const success = await updateIssueStatus(
    issue.id,
    'Testing',
    config,
    localConfig.team
  );

  if (success) {
    console.log(`Updated ${issue.identifier} to Testing`);
  }

  // Add comment to issue
  await client.createComment({
    issueId: issue.id,
    body: 'Automated comment from custom integration'
  });
}
```

--------------------------------

### Create Validation Command File (Markdown)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:write-validate.md

This markdown snippet defines the structure for a custom validation command file within the `.claude/commands/` directory. It includes placeholders for linting, type checking, and testing commands, along with a section for quick validation and error handling guidance.

```markdown
---
name: {{ $1 | default: "validate" }}
description: Run project validation (lint, type-check, test)
---

# Project Validation

Run validation checks for this project.

## Process

### 1. Lint
```bash
{{ lint-command }}
```

### 2. Type Check
```bash
{{ type-check-command }}
```

### 3. Test (optional)
```bash
{{ test-command }}
```

## Quick Validate All

```bash
{{ combined-command }}
```

## On Failure

1. Show error output
2. Identify failing file(s) and line(s)
3. Suggest fixes
4. Re-run validation after fixes

```

--------------------------------

### Load and Save Cycle Data Programmatically (TypeScript)

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Core utility functions for loading and saving local TOON format cache files containing task data and cycle information. This API is written in TypeScript and allows programmatic access to task management features.

```typescript
import { loadCycleData, saveCycleData, type CycleData, type Task } from 'team-toon-tack';

// Load current cycle data from .ttt/cycle.toon
async function processLocalTasks() {
  const data: CycleData | null = await loadCycleData();

  if (!data) {
    console.error('No cycle data found');
    return;
  }

  console.log(`Cycle: ${data.cycleName}`);
  console.log(`Tasks: ${data.tasks.length}`);
  console.log(`Last updated: ${data.updatedAt}`);

  // Filter in-progress tasks
  const inProgress = data.tasks.filter(t => t.localStatus === 'in-progress');

  for (const task of inProgress) {
    console.log(`${task.id}: ${task.title}`);
    console.log(`  Status: ${task.status} [${task.localStatus}]`);
    console.log(`  Priority: ${task.priority}`);
    console.log(`  Labels: ${task.labels.join(', ')}`);

    if (task.attachments) {
      for (const att of task.attachments) {
        console.log(`  Attachment: ${att.title}`);
        if (att.localPath) {
          console.log(`    Local: ${att.localPath}`);
        }
      }
    }
  }

  // Modify and save
  inProgress[0].localStatus = 'completed';
  await saveCycleData(data);
}
```

--------------------------------

### Manage Task Status (ttt CLI)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/README.md

Allows viewing and modifying the status of Linear tasks. Users can check the status of the current or a specific task, advance it to the next status, mark it as 'done', or set it to 'blocked' indicating a dependency.

```bash
ttt status              # Show current in-progress task
ttt status MP-123       # Show specific issue status
ttt status MP-123 --set +1      # Move to next status
ttt status MP-123 --set done    # Mark as done
ttt status MP-123 --set blocked # Set as blocked (waiting on dependency)
```

--------------------------------

### Show or Search Linear Issues with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Displays issue details or searches issues from local data. Can list all issues, show specific issues, fetch fresh data from Linear (--remote), export issues to markdown (--export), and filter by various criteria like label, status, user, or priority.

```bash
ttt show              # List all issues in local data
ttt show MP-624       # Show specific issue details
ttt show MP-624 --remote   # Fetch fresh data from Linear API
ttt show --export     # Export all issues as markdown
ttt show MP-624 --export   # Export single issue as markdown
ttt show --label frontend           # Filter by label
ttt show --status "In Progress"     # Filter by Linear status
ttt show --user me                  # Filter by current user (from config)
ttt show --user unassigned          # Show unassigned issues
ttt show --priority 1               # Filter by priority (1=Urgent, 2=High, 3=Medium, 4=Low)
ttt show --status "In Progress" --user me   # My in-progress issues
ttt show --label frontend --priority 1      # Urgent frontend issues
```

--------------------------------

### Interactive Task Selection with ttt work-on

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:work-on.md

Initiates working on a Linear task by running the 'ttt work-on' command without any arguments. This triggers an interactive selection process for the task.

```bash
ttt work-on
```

--------------------------------

### Search Issues by Label (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:show.md

Filters and displays issues that are tagged with a specific label. The '--label' option is used, followed by the label name. Replace '{{ label }}' with the desired label.

```bash
ttt show --label {{ label }}
```

--------------------------------

### Show Task Status with ttt

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Displays detailed task information from the local cache. Supports showing all issues in the cache, details for a specific issue ID, or fetching remote issue details using the `--remote` flag. Filtering options include label, status, priority, and assignee.

```bash
# Show all issues in local cycle cache
ttt show

# Show specific issue details
ttt show MP-624

# Fetch specific issue from Linear API (remote)
ttt show MP-624 --remote

# Filter by label
ttt show --label frontend

# Filter by status and user
ttt show --status "In Progress" --user me

# Show urgent priority issues
ttt show --priority 1
```

--------------------------------

### Show Specific Issue by ID (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:show.md

Retrieves and displays details for a specific issue by providing its unique issue ID. Replace '{{ issue-id }}' with the actual ID (e.g., MP-624).

```bash
ttt show {{ issue-id }}
```

--------------------------------

### Search Issues by Priority (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:show.md

Filters and displays issues based on their priority level, ranging from 0 (None) to 4 (Low). The '--priority' option is used, followed by the priority number. Replace '{{ priority }}' with the desired priority level.

```bash
ttt show --priority {{ priority }}
```

--------------------------------

### Search Issues by Assignee (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:show.md

Filters and displays issues assigned to a specific user. The '--user' option can take an email address, 'me' for the current user, or 'unassigned'. Replace '{{ user }}' with the assignee identifier.

```bash
ttt show --user {{ user }}
```

--------------------------------

### Creating a Validation Command with ttt:write-validate

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:work-on.md

Executes the 'ttt:write-validate' command to create a validation command for the project. This is used when no existing validation tools or skills are found.

```bash
/ttt:write-validate
```

--------------------------------

### Fetch Remote Data from Linear (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:show.md

Retrieves issue details directly from the Linear API instead of using local data. This is useful for fetching the most up-to-date information. It can be used with or without an issue ID, and combined with other filters.

```bash
ttt show {{ issue-id }} --remote
```

```bash
ttt show --remote --status todo
```

--------------------------------

### Extract package.json Scripts (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:write-validate.md

This bash command uses `cat` and `jq` to extract the keys (script names) from the `scripts` section of a `package.json` file. It's useful for Node.js projects to identify available linting, testing, or validation scripts.

```bash
cat package.json | jq '.scripts | keys[]' 2>/dev/null
```

--------------------------------

### Search Issues by Status (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:show.md

Filters and displays issues based on their current status in Linear. The '--status' option is used, followed by the status name, which should be enclosed in quotes if it contains spaces. Replace '{{ status }}' with the desired status.

```bash
ttt show --status "{{ status }}"
```

--------------------------------

### Completing Work Workflow with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Describes the process of completing a task using the ttt CLI. It emphasizes committing code first and then using the 'done' command, optionally with a completion message.

```bash
# Ensure code is committed first
git add . && git commit -m "feat: implement feature"

# Mark task as done with message
ttt done -m "Implemented feature with full test coverage"
```

--------------------------------

### Priority Sorting and Filtering of Tasks (TypeScript)

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Provides utility functions to sort tasks based on a configurable priority order and filter them by user assignment. It loads configuration and cycle data, sorts tasks according to a defined priority list (defaulting to urgent, high, medium, low, none), and identifies the next pending task.

```typescript
import {
  getPrioritySortIndex,
  loadConfig,
  loadCycleData,
  PRIORITY_NAMES
} from 'team-toon-tack';

async function prioritizedTaskSelection() {
  const config = await loadConfig();
  const data = await loadCycleData();

  if (!data) return;

  // Custom priority order (default: urgent, high, medium, low, none)
  const priorityOrder = config.priority_order || ['urgent', 'high', 'medium', 'low', 'none'];

  // Sort tasks by priority
  const sortedTasks = [...data.tasks].sort((a, b) => {
    const priorityA = getPrioritySortIndex(a.priority, priorityOrder);
    const priorityB = getPrioritySortIndex(b.priority, priorityOrder);
    return priorityA - priorityB;
  });

  // Display sorted tasks
  for (const task of sortedTasks) {
    const priorityName = PRIORITY_NAMES[task.priority] || 'none';
    console.log(`[${priorityName}] ${task.id}: ${task.title}`);
  }

  // Get highest priority pending task
  const nextTask = sortedTasks.find(t => t.localStatus === 'pending');
  if (nextTask) {
    console.log(`\nNext task to work on: ${nextTask.id}`);
  }
}
```

--------------------------------

### Export Filtered Results as Markdown

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Exports filtered task results to a markdown format. This command is useful for generating reports or sharing task summaries. It requires specifying the label to filter by and the export option.

```bash
# Export filtered results as markdown
ttt show --label backend --export
```

--------------------------------

### Complete a Task with ttt

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Marks a task as completed. It can automatically detect the current in-progress task or accept a specific issue ID. Supports adding an AI-generated summary message using the `-m` flag. Updates parent issues based on completion mode and adds commit information as a Linear comment.

```bash
# Complete current in-progress task (auto-detected)
ttt done

# Complete specific task
ttt done MP-624

# Complete with AI summary message
ttt done -m "Implemented JWT middleware with refresh token rotation"

# Complete specific task with message
ttt done MP-624 -m "Fixed authentication flow edge cases"
```

--------------------------------

### Sync Linear Issues with ttt

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Synchronizes Linear issues with the local cache. It can fetch active cycle issues, sync all issues regardless of status, or sync a specific issue by ID. The `--update` flag pushes local status changes to Linear for local mode synchronization.

```bash
# Sync Todo/In Progress issues from current cycle
ttt sync

# Sync all issues regardless of status
ttt sync --all

# Sync single specific issue
ttt sync MP-624

# Push local status changes to Linear (for local mode)
ttt sync --update
```

--------------------------------

### Modify Task Status using CLI

Source: https://context7.com/wayne930242/team-toon-tack/llms.txt

Allows modification of task statuses, both locally and within Linear. Supports incremental changes (+1/-1) for workflow progression and direct assignment to specific statuses. It can also set tasks to a 'blocked' state.

```bash
# Show current in-progress task status
ttt status

# Show status of specific issue
ttt status MP-624

# Move to next status (pending → in-progress → completed)
ttt status MP-624 --set +1

# Move back one status
ttt status MP-624 --set -1

# Set to specific local status
ttt status MP-624 --set pending
ttt status MP-624 --set in-progress
ttt status MP-624 --set completed

# Set to blocked (waiting on dependency)
ttt status MP-624 --set blocked

# Set Linear status directly
ttt status MP-624 --set done
ttt status MP-624 --set todo
```

--------------------------------

### Execute 'ttt done' Command (Bash)

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:done.md

This snippet demonstrates various ways to execute the 'ttt done' command in bash. It covers auto-selection, specifying an issue ID, adding a completion message, and combining these options. The command marks tasks as completed and syncs status with Linear.

```bash
ttt done
ttt done {{ issue-id }}
ttt done -m "{{ message }}"
ttt done {{ issue-id }} -m "{{ message }}"
```

--------------------------------

### Manage Linear Task Status with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Shows or modifies the status of a Linear task. Can display the status of the current task, a specific issue, or set the status to the next stage, 'done', or 'blocked'.

```bash
ttt status            # Show current in-progress task
ttt status MP-624     # Show specific issue status
ttt status MP-624 --set +1       # Move to next status
ttt status MP-624 --set done     # Mark as done
ttt status MP-624 --set blocked  # Set as blocked
```

--------------------------------

### Auto-Selecting Highest Priority Task with ttt work-on

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:work-on.md

Automatically selects the highest priority Linear task to work on by passing the 'next' keyword as the issue-id argument to the 'ttt work-on' command.

```bash
ttt work-on next
```

--------------------------------

### Mark Linear Task as Completed with ttt CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/skills/linear-task-manager/SKILL.md

Marks a Linear task as completed. Can complete the current in-progress task, a specific issue, or provide a completion message using the '-m' flag.

```bash
ttt done              # Complete current in-progress task (if only one)
ttt done MP-624       # Complete specific issue
ttt done -m "message" # Complete with a completion message
```

--------------------------------

### Set Task Status with TTT CLI

Source: https://github.com/wayne930242/team-toon-tack/blob/main/commands/ttt:status.md

Illustrates how to set a new status for a task using the TTT CLI. This involves specifying the issue ID and the desired new status using the `--set` flag. Valid status values include relative increments (+1, -1) and absolute states (pending, in-progress, completed, blocked, done).

```bash
ttt status {{ issue-id }} --set {{ set }}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.