team-toon-tack 3.2.7 → 3.2.9

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
 			"name": "team-toon-tack",
 			"source": "./",
 			"description": "Linear/Trello task sync & management CLI with commands and skills",
-			"version": "2.5.2"
+			"version": "2.6.0"
 		}
 	]
 }

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
 	"name": "team-toon-tack",
 	"description": "Linear/Trello task sync & management CLI for Claude Code - saves tokens vs MCP",
-	"version": "2.5.2",
+	"version": "2.6.0",
 	"author": {
 		"name": "wayne930242",
 		"email": "wayne930242@gmail.com"

package/commands/ttt:done.md

@@ -3,60 +3,80 @@ name: ttt:done
 description: Mark current task as completed
 arguments:
   - name: issue-id
-    description: Optional issue ID if multiple tasks in progress
+    description: Issue ID if multiple tasks in progress (e.g., MP-624)
     required: false
   - name: message
-    description: Completion message (use -m flag)
+    description: Completion message summarizing what was done
+    required: false
+  - name: from-remote
+    description: Fetch issue from Linear (bypass local data check)
     required: false
 ---
 
-# TTT Done Command
+<law>
+YOU MUST execute the `ttt done` command using the Bash tool.
+DO NOT manually edit cycle.toon or Linear status by other means.
+DO NOT skip this command — it updates both local and remote status, posts a completion comment, and syncs state.
+</law>
 
-Mark the current in-progress task as completed.
+# /ttt:done — Complete a Task
 
-## Usage
+## Execution
 
-### Auto-Select (single in-progress task)
 ```bash
-ttt done
+ttt done {{ issue-id }} {{ "-m \"" + message + "\"" if message }} {{ "--from-remote" if from-remote }}
 ```
 
-### Specific Issue
-If `issue-id` is provided:
+### Common Examples
+
 ```bash
-ttt done {{ issue-id }}
+ttt done                                # Complete current in-progress task
+ttt done MP-624                         # Complete specific task
+ttt done -m "Fixed null check"          # With completion message
+ttt done MP-624 -m "Refactored auth"    # Specific task with message
+ttt done MP-624 --from-remote           # Issue not in local data
 ```
 
-### With Completion Message
-If `message` is provided:
-```bash
-ttt done -m "{{ message }}"
+## Full CLI Reference
+
 ```
+Usage: ttt done [issue-id] [-m message] [--from-remote]
 
-### Combined
-```bash
-ttt done {{ issue-id }} -m "{{ message }}"
+Arguments:
+  issue-id              Optional. Issue ID if multiple tasks in-progress
+
+Options:
+  -m, --message         Completion message describing what was done
+  -r, --from-remote     Fetch issue from Linear (bypass local data check)
 ```
 
-## What This Does
+## Before Running
+
+Ensure:
+1. Code changes are committed (`git add && git commit`)
+2. Code quality checks passed (lint, type-check) if applicable
+
+## What It Does
 
 Based on configured completion mode:
 
-| Mode | Behavior |
-|------|----------|
-| `simple` | Task → Done, Parent → Done |
-| `strict_review` | Task → Testing, Parent → QA Testing |
-| `upstream_strict` | Task → Done, Parent → Testing |
-| `upstream_not_strict` | Task → Done, Parent → Testing (no fallback) |
+| Mode | Task Status | Parent Status |
+|------|-------------|---------------|
+| `simple` | → Done | → Done |
+| `strict_review` | → Testing | → QA Testing |
+| `upstream_strict` | → Done | → Testing |
+| `upstream_not_strict` | → Done | → Testing (no fallback) |
 
-Also:
-1. Gets latest git commit info
-2. Adds completion comment to Linear with commit details
-3. Syncs task back from Linear to update local status
+Additionally:
+- Reads latest git commit info
+- Posts completion comment to Linear with commit details
+- Syncs task back from Linear to update local status
 
-## Before Running
+## Error Handling
 
-Ensure you have:
-1. Committed your changes with a meaningful message
-2. Pushed to remote branch (if applicable)
-3. Verified code quality (lint, type-check) if applicable
+| Error | Solution |
+|-------|----------|
+| `No in-progress task` | Specify issue-id explicitly |
+| `Multiple in-progress` | Specify issue-id to disambiguate |
+| `Issue not found` | Use `--from-remote` flag |
+| `No commits found` | Commit your changes first |

package/commands/ttt:show.md

@@ -6,121 +6,85 @@ arguments:
     description: Issue ID to show (e.g., MP-624)
     required: false
   - name: label
-    description: Filter by label (--label <label>)
+    description: Filter by label
     required: false
   - name: status
-    description: Filter by status (--status <status>)
+    description: "Filter by status (e.g., 'In Progress', 'Todo')"
     required: false
   - name: user
-    description: Filter by assignee (--user <email|me|unassigned>)
+    description: "Filter by assignee (email, 'me', or 'unassigned')"
     required: false
   - name: priority
-    description: Filter by priority (--priority <0-4>)
+    description: "Filter by priority (0=None, 1=Urgent, 2=High, 3=Medium, 4=Low)"
     required: false
   - name: remote
-    description: Fetch from Linear instead of local data (--remote)
+    description: Fetch from Linear API instead of local data
     required: false
   - name: export
-    description: Output as markdown format (--export)
+    description: Output as markdown format
     required: false
 ---
 
-# TTT Show Command
+<law>
+YOU MUST execute the `ttt show` command using the Bash tool.
+DO NOT read cycle.toon directly — the CLI handles formatting and filtering.
+DO NOT simulate or fabricate issue data.
+</law>
 
-Show issue details or search issues from local cycle data.
+# /ttt:show — Show Issues
 
-## Usage
+## Execution
 
-### Show All Issues
-```bash
-ttt show
-```
+Build the command from arguments and run it:
 
-### Show Specific Issue
 ```bash
-ttt show {{ issue-id }}
+ttt show {{ issue-id }} \
+  {{ "--label " + label if label }} \
+  {{ "--status \"" + status + "\"" if status }} \
+  {{ "--user " + user if user }} \
+  {{ "--priority " + priority if priority }} \
+  {{ "--remote" if remote }} \
+  {{ "--export" if export }}
 ```
 
-### Search by Filters
-```bash
-ttt show --label {{ label }}
-ttt show --status "{{ status }}"
-ttt show --user {{ user }}
-ttt show --priority {{ priority }}
-```
+### Common Examples
 
-### Fetch from Linear (Remote)
 ```bash
-ttt show {{ issue-id }} --remote
-ttt show --remote --status todo
+ttt show                                    # List all local issues
+ttt show MP-624                             # Show specific issue
+ttt show MP-624 --remote                    # Fetch fresh from Linear
+ttt show MP-624 --export                    # Export as markdown
+ttt show --label frontend                   # Filter by label
+ttt show --status "In Progress" --user me   # My in-progress issues
+ttt show --priority 1                       # All urgent issues
+ttt show --export                           # Export all as markdown
 ```
 
-## What This Does
-
-1. By default, reads from local cycle.toon data (no API calls)
-2. Supports filtering by label, status, user, priority
-3. Use --remote to fetch fresh data from Linear API
-4. Displays comprehensive information:
-   - Title and description
-   - Status (both Linear and local)
-   - Priority level
-   - Labels
-   - Assignee
-   - Branch name
-   - Parent issue (if subtask)
-   - Attachments with local paths
-   - Comments with timestamps
-
-## Filter Options
-
-| Option | Description | Example |
-|--------|-------------|---------|
-| `--label` | Filter by label name | `--label frontend` |
-| `--status` | Filter by Linear status | `--status "In Progress"` |
-| `--user` | Filter by assignee | `--user me`, `--user unassigned` |
-| `--priority` | Filter by priority (0-4) | `--priority 1` (Urgent) |
-| `--remote` | Fetch from Linear API | `--remote` |
-| `--export` | Output as markdown | `--export` |
-
-## Priority Values
-
-- 0: None
-- 1: Urgent
-- 2: High
-- 3: Medium
-- 4: Low
+## Full CLI Reference
 
-## Use Cases
-
-- List all issues in current cycle
-- Search issues by label or status
-- Review issue details before starting work
-- Check requirements and acceptance criteria
-- View attachments and mockups
-- Read comment history and discussions
-
-## Examples
-
-```bash
-# Show all local issues
-ttt show
-
-# Show specific issue
-ttt show MP-624
-
-# My in-progress issues
-ttt show --status "In Progress" --user me
+```
+Usage: ttt show [issue-id] [options]
+
+Arguments:
+  issue-id              Optional. Show specific issue (e.g., MP-624)
+
+Options:
+  --remote              Fetch from Linear instead of local data
+  --export              Output as markdown format
+  --label <label>       Filter by label
+  --status <status>     Filter by status
+  --user <email>        Filter by assignee ("me", "unassigned", or email)
+  --priority <n>        Filter by priority (0=None, 1=Urgent, 2=High, 3=Medium, 4=Low)
+```
 
-# All urgent issues
-ttt show --priority 1
+## After Execution
 
-# Frontend issues
-ttt show --label frontend
+Present the output to the user. If `--export` was used, the output is markdown-formatted and can be used as context.
 
-# Fetch fresh data from Linear
-ttt show MP-624 --remote
+## Error Handling
 
-# Export as markdown
-ttt show --export
-ttt show MP-624 --export
-```
+| Error | Solution |
+|-------|----------|
+| `No cycle data found` | Run `ttt sync` first |
+| `Issue not found` | Try `ttt show <id> --remote` or `ttt sync <id>` |
+| `LINEAR_API_KEY not set` | Required for `--remote`; ask user to set it |

package/commands/ttt:status.md

@@ -6,60 +6,74 @@ arguments:
     description: Issue ID to check/modify (omit for current in-progress task)
     required: false
   - name: set
-    description: New status to set (+1, -1, pending, in-progress, completed, blocked, done)
+    description: "New status: +1, -1, +2, -2, pending, in-progress, completed, blocked, todo, done"
     required: false
 ---
 
-# TTT Status Command
+<law>
+YOU MUST execute the `ttt status` command using the Bash tool.
+DO NOT manually edit cycle.toon or manipulate status by other means.
+The CLI handles both local and remote status synchronization.
+</law>
 
-Show or modify the status of a task.
+# /ttt:status — Show or Modify Task Status
 
-## Usage
+## Execution
 
-### Show Current In-Progress Task
 ```bash
-ttt status
+ttt status {{ issue-id }} {{ "--set " + set if set }}
 ```
 
-### Show Specific Issue
-If `issue-id` is provided:
+### Common Examples
+
 ```bash
-ttt status {{ issue-id }}
+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 blocked     # Mark as blocked
+ttt status --set pending            # Reset current task
 ```
 
-### Set Status
-If `set` is provided:
-```bash
-ttt status {{ issue-id }} --set {{ set }}
+## Full CLI Reference
+
 ```
+Usage: ttt status [issue-id] [--set <status>]
 
-## Status Values
+Arguments:
+  issue-id              Optional. Issue ID (omit for current in-progress task)
 
-| Value | Description |
-|-------|-------------|
-| `+1` | Move to next status (pending → in-progress → completed) |
-| `-1` | Move to previous status |
-| `+2` | Skip two statuses forward |
-| `-2` | Skip two statuses backward |
-| `pending` | Set to pending |
-| `in-progress` | Set to in-progress |
-| `completed` | Set to completed |
-| `blocked` | Set to blocked (waiting on dependency) |
-| `todo` | Set Linear to Todo status |
-| `done` | Set Linear to Done status |
+Options:
+  -s, --set <status>    Set status. Values:
+                        +1           Next status (pending → in-progress → completed)
+                        -1           Previous status
+                        +2           Skip two forward
+                        -2           Skip two backward
+                        pending      Set to pending
+                        in-progress  Set to in-progress
+                        completed    Set to completed
+                        blocked      Set to blocked
+                        todo         Set Linear to Todo
+                        done         Set Linear to Done
+```
 
-## Examples
+## Status Flow
 
-```bash
-ttt status MP-624 --set +1       # Move to next status
-ttt status MP-624 --set blocked  # Mark as blocked
-ttt status --set pending         # Reset current task
+```
+pending → in-progress → completed
+               ↓
+            blocked
 ```
 
-## Output
+## After Execution
 
-Displays:
+Report:
 - Task ID and title
 - Local status vs Linear status
 - Priority and labels
-- Assignee information
+
+## Error Handling
+
+| Error | Solution |
+|-------|----------|
+| `No in-progress task` | Specify issue-id or run `ttt work-on` first |
+| `Issue not found` | Run `ttt sync` to refresh local data |

package/commands/ttt:sync.md

@@ -5,47 +5,63 @@ arguments:
   - name: issue-id
     description: Optional specific issue ID to sync (e.g., MP-624)
     required: false
-  - name: update
-    description: Push local status changes to Linear (add --update flag)
+  - name: flags
+    description: "Additional flags: --all (all statuses), --update (push local changes)"
     required: false
 ---
 
-# TTT Sync Command
+<law>
+YOU MUST execute the `ttt sync` command using the Bash tool.
+DO NOT simulate, summarize, or skip the command.
+DO NOT manually edit cycle.toon or any .ttt/ files.
+The CLI handles all syncing logic — your job is to run it and report the output.
+</law>
 
-Sync issues from Linear to local `.ttt/cycle.toon` file.
+# /ttt:sync — Sync Issues
 
-## Usage
+## Execution
 
-Run the sync command based on arguments provided:
+Build the command from arguments and run it:
 
-### Default Sync (all matching issues)
 ```bash
-ttt sync
+ttt sync {{ issue-id }} {{ flags }}
 ```
 
-### Sync Specific Issue
-If `issue-id` is provided:
-```bash
-ttt sync {{ issue-id }}
-```
+### Argument Resolution
+
+| Input | Command |
+|-------|---------|
+| (none) | `ttt sync` |
+| `MP-624` | `ttt sync MP-624` |
+| `--all` | `ttt sync --all` |
+| `--update` | `ttt sync --update` |
+| `MP-624 --all` | `ttt sync MP-624 --all` |
+
+## Full CLI Reference
 
-### Push Local Changes
-If `update` is "true" or "--update":
-```bash
-ttt sync --update
 ```
+Usage: ttt sync [issue-id] [--all] [--update]
 
-## What This Does
+Arguments:
+  issue-id    Optional. Sync only this specific issue (e.g., MP-624)
 
-1. Fetches active cycle from Linear
-2. Downloads all issues matching configured filters (team, status, labels)
-3. Preserves local status for existing tasks
-4. Downloads Linear images to `.ttt/output/`
-5. Updates `cycle.toon` with fresh data
+Options:
+  --all       Sync all issues regardless of status (default: only Todo/In Progress)
+  --update    Push local status changes to Linear (for local mode users)
+```
 
-## Output
+## After Execution
 
-After running, report:
+Report to the user:
 - Number of tasks synced
 - Current cycle name
-- Any status updates pushed to Linear (if --update used)
+- Any errors encountered
+
+## Error Handling
+
+| Error | Solution |
+|-------|----------|
+| `LINEAR_API_KEY not set` | Ask user to set `LINEAR_API_KEY` environment variable |
+| `No cycle data found` | Cycle may not exist in Linear; ask user to verify |
+| `No config found` | Run `ttt init` first |
+| Network error | Retry once, then report to user |

package/commands/ttt:work-on.md

@@ -3,102 +3,80 @@ name: ttt:work-on
 description: Start working on a Linear task
 arguments:
   - name: issue-id
-    description: Issue ID (e.g., MP-624). Defaults to 'next' (auto-select highest priority)
+    description: "Issue ID (e.g., MP-624) or 'next' for auto-select. Defaults to 'next'."
     required: false
     default: next
+  - name: dry-run
+    description: Preview selection without changing status
+    required: false
 ---
 
-# TTT Work-On Command
+<law>
+YOU MUST execute the `ttt work-on` command using the Bash tool.
+DO NOT manually edit cycle.toon or change task status by other means.
+After the task is completed, YOU MUST execute `/ttt:done -m "summary"`. This is MANDATORY.
+</law>
 
-Start working on a task from the current cycle.
+# /ttt:work-on — Start Working on a Task
 
-## Usage
+## Execution
 
-### Auto-Select Highest Priority (Default)
 ```bash
-ttt work-on next
+ttt work-on {{ issue-id | default: "next" }} {{ "--dry-run" if dry-run }}
 ```
 
-### Specific Issue
-```bash
-ttt work-on {{ issue-id }}
-```
+### Argument Resolution
 
-### Preview Mode (Dry Run)
-```bash
-ttt work-on --dry-run        # Interactive selection, preview only
-ttt work-on next --dry-run   # Auto-select, preview only
-```
+| Input | Command |
+|-------|---------|
+| (none) | `ttt work-on next` |
+| `next` | `ttt work-on next` |
+| `MP-624` | `ttt work-on MP-624` |
+| `--dry-run` | `ttt work-on next --dry-run` |
+| `MP-624 --dry-run` | `ttt work-on MP-624 --dry-run` |
 
-Use `--dry-run` to preview task selection without changing any status.
+## Full CLI Reference
 
-## What This Does
+```
+Usage: ttt work-on [issue-id] [options]
+
+Arguments:
+  issue-id    Issue ID (e.g., MP-624) or 'next' for auto-select
+              If omitted, shows interactive selection
 
-1. Marks the task as `in-progress` locally
-2. Updates Linear status to "In Progress" (if status_source is remote)
-3. Displays full task details including:
-   - Title and description
-   - Priority and labels
-   - Attachments and comments
-   - Branch name for checkout
+Options:
+  --dry-run   Pick task without changing status (preview only)
+```
 
-## After Running
+## After Execution
 
-1. Read the task description and requirements
+1. Read the task description and requirements from the output
 2. Check out the suggested branch: `git checkout -b <branch-name>`
-3. **Check for work-on skill** (see below)
+3. Check for project-specific **work-on skill** in `.claude/skills/`
 4. Begin implementation
 
-## CRITICAL: After Task Completion
-
-**MUST execute `/ttt:done` when the task is completed.**
-
-This is MANDATORY. After finishing implementation:
+## CRITICAL: Task Completion Contract
 
-1. Commit changes: `git add . && git commit -m "..."`
-2. **Execute `/ttt:done -m "completion summary"`**
+When the task is completed, you MUST execute:
 
-Do NOT skip this step. The task is not complete until `/ttt:done` is executed.
-
-## Work-On Skill
-
-Check for project-specific work guidelines:
-
-### 1. Check for Existing Work-On Skill
-
-Look for:
-- **Skills**: `work-on`, `start-work`, `begin-task` in `.claude/skills/`
-- **Alternative**: Check for `validate`, `check` skills that define project guidelines
-
-### 2. If No Work-On Skill Found
-
-Suggest user create one:
 ```
-No work-on skill found for this project.
+/ttt:done -m "completion summary"
+```
 
-A work-on skill defines best practices for starting tasks:
-- Code style and conventions
-- Pre-work validation checks
-- Branch naming conventions
-- Required setup steps
+A task is NOT complete until `/ttt:done` is executed. Do NOT skip this step.
 
-Would you like to create one? (y/n)
-```
+## Work-On Skill Integration
 
-If yes, run:
-```
-/ttt:write-work-on-skill
-```
+After starting a task, check for project-specific work guidelines:
 
-The work-on skill should include:
-- **Validation**: lint, type-check, test commands
-- **Code style**: formatting, naming conventions
-- **Workflow**: branch naming, commit message format
-- **Setup**: required dependencies, environment checks
+1. Look for `work-on` or `start-work` skills in `.claude/skills/`
+2. If found, follow those guidelines
+3. If not found, suggest creating one with `/ttt:write-work-on-skill`
 
-### 3. Use Work-On Skill
+## Error Handling
 
-Once available:
-- Follow the guidelines defined in the skill
-- Run any validation checks specified
-- Ensure code style compliance
+| Error | Solution |
+|-------|----------|
+| `No cycle data found` | Run `ttt sync` first |
+| `No eligible tasks` | All tasks assigned or in-review; run `ttt sync` to refresh |
+| `Issue not found` | Run `ttt sync <id>` to fetch it |

package/dist/scripts/lib/display.js

@@ -30,7 +30,6 @@ export function displayTaskInfo(task) {
     console.log(`Labels: ${task.labels.join(", ")}`);
     if (task.assignee)
         console.log(`Assignee: ${task.assignee}`);
-    console.log(`Branch: ${task.branch || "N/A"}`);
     if (task.url)
         console.log(`URL: ${task.url}`);
 }
@@ -94,7 +93,6 @@ export function displayTaskWithStatus(task) {
     console.log(`  Priority: ${PRIORITY_LABELS[task.priority] || "None"}`);
     console.log(`  Labels: ${task.labels.join(", ")}`);
     console.log(`  Assignee: ${task.assignee || "Unassigned"}`);
-    console.log(`  Branch: ${task.branch || "N/A"}`);
     if (task.url)
         console.log(`  URL: ${task.url}`);
     displayTaskDescription(task);

package/dist/scripts/lib/sync.js

@@ -49,7 +49,6 @@ export async function fetchIssueDetail(issueId, options = {}) {
         assignee: assigneeEmail,
         priority: issue.priority,
         labels: labelNames,
-        branch: issue.branchName,
         description: issue.description ?? undefined,
         parentIssueId: parent ? parent.identifier : undefined,
         url: issue.url,

package/dist/scripts/show.js

@@ -10,8 +10,6 @@ function taskToMarkdown(task) {
     lines.push(`- **Priority**: ${priority}`);
     lines.push(`- **Labels**: ${task.labels.length > 0 ? task.labels.join(", ") : "-"}`);
     lines.push(`- **Assignee**: ${task.assignee || "Unassigned"}`);
-    if (task.branch)
-        lines.push(`- **Branch**: \`${task.branch}\``);
     if (task.url)
         lines.push(`- **URL**: ${task.url}`);
     if (task.parentIssueId)
@@ -106,7 +104,6 @@ async function fetchIssueFromRemote(issueId) {
         assignee: issue.assigneeEmail,
         priority: issue.priority,
         labels: issue.labels,
-        branch: issue.branchName,
         description: issue.description,
         parentIssueId: issue.parentIssueId,
         url: issue.url,
@@ -178,7 +175,6 @@ async function searchIssuesFromRemote(filters) {
             assignee: issue.assigneeEmail,
             priority: issue.priority,
             labels: issue.labels,
-            branch: issue.branchName,
             description: issue.description,
             parentIssueId: issue.parentIssueId,
             url: issue.url,

package/dist/scripts/sync.js

@@ -336,7 +336,6 @@ Examples:
             assignee: assigneeEmail,
             priority: issue.priority,
             labels: labelNames,
-            branch: issue.branchName,
             description: issue.description ?? undefined,
             parentIssueId: parent ? parent.identifier : undefined,
             url: issue.url,
@@ -535,7 +534,6 @@ async function syncTrello(config, localConfig, options) {
             assignee: issue.assigneeEmail,
             priority: issue.priority,
             labels: issue.labels,
-            branch: issue.branchName,
             description: issue.description,
             parentIssueId: issue.parentIssueId,
             url: issue.url,

package/dist/scripts/work-on.js

@@ -34,9 +34,17 @@ Examples:
     const localConfig = await loadLocalConfig();
     // Get current user email for filtering
     const currentUserEmail = config.users[localConfig.current_user]?.email;
+    const normalizedCurrentUserEmail = currentUserEmail?.toLowerCase();
     const pendingTasks = data.tasks
-        .filter((t) => t.localStatus === "pending" &&
-        (!currentUserEmail || t.assignee === currentUserEmail))
+        .filter((t) => {
+        if (t.localStatus !== "pending")
+            return false;
+        if (!normalizedCurrentUserEmail)
+            return true;
+        if (!t.assignee)
+            return true; // Include unassigned tasks
+        return t.assignee.toLowerCase() === normalizedCurrentUserEmail;
+    })
         .sort((a, b) => {
         const pa = getPrioritySortIndex(a.priority, config.priority_order);
         const pb = getPrioritySortIndex(b.priority, config.priority_order);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "team-toon-tack",
-	"version": "3.2.7",
+	"version": "3.2.9",
 	"description": "Linear & Trello task sync & management CLI with TOON format",
 	"type": "module",
 	"bin": {

package/skills/managing-linear-tasks/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: managing-linear-tasks
+description: Use when the user mentions Linear or Trello issues, references issue IDs like MP-123, or asks to sync, show, start, complete, or check status of tasks.
+---
+
+<law>
+ALL task operations MUST go through the `ttt` CLI via Bash tool.
+NEVER manually edit `.ttt/` files (cycle.toon, config.toon, local.toon).
+NEVER fabricate issue data — always run the CLI to get real data.
+After completing any task, MUST execute `/ttt:done -m "summary"`.
+</law>
+
+# Task Manager (Linear/Trello)
+
+Manage developer task workflows using the `ttt` CLI.
+
+## Command Router
+
+Match user intent to the correct `/ttt:*` command:
+
+| User Intent | Command | Example |
+|-------------|---------|---------|
+| Sync/fetch issues | `/ttt:sync` | "sync my issues", "pull from Linear" |
+| Show/search issues | `/ttt:show` | "show MP-624", "list my tasks", "what issues do I have" |
+| Start working on a task | `/ttt:work-on` | "work on next", "start MP-624" |
+| Check/change status | `/ttt:status` | "what's my current task", "set MP-624 to blocked" |
+| Complete a task | `/ttt:done` | "done", "mark complete", "finish task" |
+
+**When a matching intent is detected, invoke the corresponding `/ttt:*` slash command.**
+
+## Quick Reference
+
+```bash
+ttt sync                    # Sync Todo/In Progress issues
+ttt sync --all              # Sync all statuses
+ttt sync MP-624             # Sync specific issue
+ttt show                    # List all local issues
+ttt show MP-624             # Show issue details
+ttt show --user me          # My issues
+ttt work-on next            # Auto-select highest priority
+ttt work-on MP-624          # Start specific task
+ttt status                  # Current in-progress task
+ttt status MP-624 --set +1  # Advance status
+ttt done -m "summary"       # Complete with message
+```
+
+## Prerequisites
+
+- **Linear**: `LINEAR_API_KEY` env var set
+- **Trello**: `TRELLO_API_KEY` + `TRELLO_TOKEN` env vars set
+- `.ttt/` directory initialized (`ttt init`)
+
+## Standard Workflow
+
+```
+ttt sync → ttt work-on next → [implement] → git commit → ttt done -m "..."
+```
+
+## File Structure
+
+```
+.ttt/
+├── config.toon     # Team configuration
+├── local.toon      # Personal settings
+├── cycle.toon      # Current cycle tasks (auto-generated)
+└── output/         # Downloaded attachments
+```
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| No cycle data | `ttt sync` |
+| Issue not found locally | `ttt show <id> --remote` or `ttt sync <id>` |
+| API key not set | Set `LINEAR_API_KEY` or `TRELLO_API_KEY` + `TRELLO_TOKEN` |
+| Stale data | `ttt sync` to refresh |

package/skills/linear-task-manager/SKILL.md

@@ -1,317 +0,0 @@
----
-name: linear-task-manager
-description: Task management expert using ttt CLI. Manages task workflow, syncs issues, tracks status. Supports Linear and Trello. Use when working with issues/cards, starting tasks, completing work, or checking task status.
----
-
-# Task Manager (Linear/Trello)
-
-You are a task management expert using the team-toon-tack (ttt) CLI tool.
-
-## Your Role
-
-Help developers efficiently manage their task workflow:
-- Sync issues/cards from Linear or Trello to local cache
-- Start working on tasks
-- Track and update task status
-- Complete tasks with proper documentation
-- Fetch issue details on demand
-
-## Prerequisites
-
-Ensure the project has:
-1. Environment variables set:
-   - **Linear**: `LINEAR_API_KEY`
-   - **Trello**: `TRELLO_API_KEY` and `TRELLO_TOKEN`
-2. `.ttt/` directory initialized (run `ttt init` if not)
-3. `ttt` CLI installed (`npm install -g team-toon-tack`)
-
-## Command Reference
-
-### `ttt sync`
-
-Sync issues from Linear/Trello to local cycle.toon file.
-
-```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 remote first, then sync
-```
-
-**Default behavior**: Only syncs issues with Todo or In Progress status for faster performance. Use `--all` when you need completed/testing issues.
-
-### `ttt show`
-
-Show issue details or search issues from local cycle data.
-
-```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 remote API
-ttt show --export     # Export all issues as markdown
-ttt show MP-624 --export   # Export single issue as markdown
-```
-
-**Filter options**:
-```bash
-ttt show --label frontend           # Filter by label
-ttt show --status "In Progress"     # Filter by 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)
-```
-
-**Combine filters**:
-```bash
-ttt show --status "In Progress" --user me   # My in-progress issues
-ttt show --label frontend --priority 1      # Urgent frontend issues
-```
-
-### `ttt work-on`
-
-Start working on a task.
-
-```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
-```
-
-### `ttt done`
-
-Mark task as completed.
-
-```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
-ttt done MP-624 --from-remote    # Fetch from remote (bypasses local data check)
-```
-
-Use `--from-remote` (or `-r`) when the issue exists in remote but not in local sync data.
-
-### `ttt status`
-
-Show or modify task status.
-
-```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
-```
-
-## Core Workflows
-
-### 1. Starting a Work Session
-
-```bash
-# Sync latest issues from remote (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
-```
-
-### 2. During Development
-
-```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
-```
-
-### 3. Completing Work
-
-```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"
-```
-
-### 4. Syncing Changes
-
-```bash
-# Pull latest from remote (fast - only Todo/In Progress)
-ttt sync
-
-# Pull ALL issues including completed ones
-ttt sync --all
-
-# Push local status changes to remote (if using local mode)
-ttt sync --update
-```
-
-## Status Flow
-
-```
-pending → in-progress → completed
-              ↓
-           blocked
-```
-
-### Local Status vs Remote Status
-
-| Local Status | Linear Status | Trello List |
-|--------------|---------------|-------------|
-| pending | Todo | Todo |
-| in-progress | In Progress | In Progress |
-| completed | Done / Testing | Done |
-| blocked | (configurable) | (configurable) |
-
-## Completion Modes (Linear only)
-
-The `ttt done` command behaves differently based on configured mode:
-
-| Mode | Task Action | Parent Action |
-|------|-------------|---------------|
-| `simple` | → Done | → Done |
-| `strict_review` | → Testing | → QA Testing |
-| `upstream_strict` | → Done | → Testing |
-| `upstream_not_strict` | → Done | → Testing (no fallback) |
-
-> **Note**: Trello always uses simple completion mode as it doesn't support parent issues.
-
-## File Structure
-
-```
-.ttt/
-├── config.toon     # Team configuration (users, teams, status mappings)
-├── local.toon      # Personal settings (current_user, team, filters)
-├── cycle.toon      # Current cycle tasks (auto-generated by sync)
-└── output/         # Downloaded attachments and images
-```
-
-## Source-Specific Notes
-
-### Linear
-- Supports cycles (sprints)
-- Supports parent issues and completion modes
-- Uses workflow states for status
-
-### Trello
-- Uses boards instead of teams
-- Uses lists for status
-- No cycle or parent issue support
-- Always uses simple completion mode
-
-## Work-On Skill
-
-Before starting tasks, check for project-specific work guidelines:
-
-1. **Check for work-on skill**: Look for `work-on`, `start-work` skills in `.claude/skills/`
-2. **Check package.json/Makefile**: Look for `lint`, `type-check`, `test` scripts
-
-If no work-on skill exists, suggest running `/ttt:write-work-on-skill` to create project-specific best practices (includes validation, code style, workflow conventions).
-
-## CRITICAL: Task Completion
-
-**MUST execute `/ttt:done` when any task is completed.**
-
-This is MANDATORY - never skip this step:
-
-```bash
-# After committing changes
-/ttt:done -m "completion summary"
-```
-
-A task is NOT complete until `/ttt:done` is executed.
-
-## Best Practices
-
-### DO
-- Always `ttt sync` before starting work
-- **Check for work-on skill** before starting tasks
-- Use `ttt work-on next` for auto-prioritization
-- **MUST execute `/ttt:done -m "..."` after completing any task**
-- Include meaningful messages with `ttt done -m "..."`
-- Check `ttt status` to verify state before commits
-- Use `ttt show --export` to get issue context as markdown
-
-### DON'T
-- Don't manually edit `cycle.toon` - use CLI commands
-- Don't skip sync - local data may be stale
-- Don't forget to commit before `ttt done`
-- **Don't forget to execute `/ttt:done` after task completion**
-- Don't mark tasks done without verification
-- Don't use `--all` on sync unless you need completed issues
-
-## Troubleshooting
-
-### "No cycle data found"
-Run `ttt sync` to fetch issues from remote.
-
-### "Issue not found in local data"
-The issue may not be synced. Try:
-- Use `ttt done MP-624 --from-remote` to complete directly from remote
-- Run `ttt sync MP-624` to sync the specific issue
-- Run `ttt sync --all` to fetch all issues including completed
-- Use `ttt show MP-624 --remote` to fetch directly from remote
-- Check if issue is in active cycle (Linear) or board (Trello)
-
-### "LINEAR_API_KEY not set" / "TRELLO credentials not set"
-```bash
-# For Linear
-export LINEAR_API_KEY="lin_api_xxxxx"
-
-# For Trello
-export TRELLO_API_KEY="your-api-key"
-export TRELLO_TOKEN="your-token"
-```
-
-## Examples
-
-### Example: Start Daily Work
-```bash
-ttt sync                    # Get latest Todo/In Progress issues
-ttt work-on next           # Auto-select highest priority
-# Read task details displayed
-git checkout -b feature/mp-624-new-feature
-# Start coding...
-```
-
-### Example: Complete and Move On
-```bash
-git add . && git commit -m "feat: add new feature"
-ttt done -m "Added feature with tests"
-ttt work-on next           # Move to next task
-```
-
-### Example: Check Specific Issue
-```bash
-ttt show MP-624            # Show from local data
-ttt show MP-624 --remote   # Fetch from remote
-ttt show MP-624 --export   # Export as markdown
-```
-
-### Example: Find My Tasks
-```bash
-ttt show --user me                          # All my issues
-ttt show --user me --status "In Progress"   # My in-progress issues
-ttt show --user me --export                 # Export my issues as markdown
-```
-
-## Important Rules
-
-- Verify API credentials are set before operations
-- Run `ttt sync` at the start of each work session
-- Commit code before running `ttt done`
-- Use `ttt show` (default) to read from local data; use `--remote` only when needed
-- Use `ttt sync` (default) for fast sync; use `--all` only when needed
-- Check `.ttt/output/` for downloaded attachments and images