@smartsoft001-mobilems/claude-plugins 2.80.0 → 2.81.0

package/plugins/flow-legacy/skills/impl/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: impl
-description: Implement plans from Linear task comments using Angular 14 legacy patterns. Iteratively processes subtasks with TDD, UI classification, agent orchestration, and 3x3 rule checkpoints.
+description: Implement plans from `plan.md` attachments on Linear issues using Angular 14 legacy patterns. Iteratively processes subtasks with TDD, UI classification, agent orchestration (saved as `orchestration.md` attachment), and 3x3 rule checkpoints.
 allowed-tools:
   - Bash
   - Read
@@ -14,17 +14,20 @@ allowed-tools:
   - TaskUpdate
   - TaskList
   - TaskGet
-  - mcp__linear-server__get_issue
-  - mcp__linear-server__list_issues
-  - mcp__linear-server__list_comments
-  - mcp__linear-server__create_comment
-  - mcp__linear-server__update_issue
-  - mcp__linear-server__list_issue_statuses
+  - mcp__linear__get_issue
+  - mcp__linear__list_issues
+  - mcp__linear__list_comments
+  - mcp__linear__save_comment
+  - mcp__linear__save_issue
+  - mcp__linear__list_issue_statuses
+  - mcp__linear__create_attachment
+  - mcp__linear__get_attachment
+  - mcp__linear__delete_attachment
 ---
 
 # Implementation Skill
 
-Implement plans from Linear task comments. For tasks with subtasks, iteratively implement each subtask that is in "To Do" status.
+Implement plans from `plan.md` attachments on Linear issues. For tasks with subtasks, iteratively implement each subtask that is in "To Do" status. The agent orchestration plan is saved as an `orchestration.md` attachment (not as a comment).
 
 ## Execution Checklist
 
@@ -37,9 +40,9 @@ Execute each step in order. Do not skip any step marked as MANDATORY.
 ### Per Subtask (repeat for each "To Do" subtask)
 
 - [ ] **2. Set status to "In Progress"** — update subtask status via MCP (subtasks only, not parent)
-- [ ] **3. Fetch implementation plan** — find `## Implementation Plan` in task comments
+- [ ] **3. Fetch implementation plan** — download `plan.md` attachment from task, parse content
 - [ ] **4. MANDATORY: UI change classification** — delegate to `shared-ui-classifier` agent, output `UI_CHANGE_REQUIRED: YES/NO`
-- [ ] **5. MANDATORY: Agent orchestration plan** — delegate to `shared-impl-orchestrator` with `Angular Version: 14 (LEGACY)`, post plan to Linear
+- [ ] **5. MANDATORY: Agent orchestration plan** — delegate to `shared-impl-orchestrator` with `Angular Version: 14 (LEGACY)`, save result as `orchestration.md` attachment on the task (replacing any existing one)
 - [ ] **6. Check external library blockers** — if blockers found, set status to Blocked and skip
 - [ ] **7. Capture "before" screenshots** — if `UI_CHANGE_REQUIRED: YES`, launch `screenshot-reporter` in background
 - [ ] **8. MANDATORY: Implement with 3x3 rule** — pause every 3 changes, use `shared-tdd-developer` for ALL code (RED → GREEN → REFACTOR)
@@ -212,7 +215,7 @@ export class DataService {
 
 ## Instructions
 
-You are tasked with implementing plans from Linear task comments. If the task has subtasks, you will iterate through subtasks in "To Do" status and implement them one by one.
+You are tasked with implementing plans from `plan.md` attachments on Linear tasks. If the task has subtasks, you will iterate through subtasks in "To Do" status and implement them one by one. The agent orchestration plan is saved as an `orchestration.md` attachment on each task (not as a comment).
 
 ### Step 1-2: Fetch Linear Task and Subtasks
 
@@ -241,24 +244,19 @@ For each task to implement (subtasks in "To Do" status, or parent task if no sub
 
 Do NOT change status for parent tasks.
 
-#### Step 3b: Fetch Implementation Plan from Comments
+#### Step 3b: Fetch Implementation Plan from `plan.md` Attachment
 
-Use the MCP Linear server to fetch all comments for the current task/subtask.
+Use `mcp__linear__get_issue({ id: taskId })` on the current task/subtask — the response includes an `attachments` array. Find the attachment where `title == "plan.md"` (or `filename == "plan.md"`) and capture its `id`.
 
-Look for a comment containing:
-
-- `## Implementation Plan` (for parent tasks)
-- `## Implementation Plan for Subtask` (for subtasks)
-
-Extract the plan details:
+If found, fetch its content via `mcp__linear__get_attachment({ id: <attachmentId> })` (Linear hosts the file natively). Parse the markdown for:
 
 - Implementation Steps
 - Files to Modify
 - New Files to create
 - Testing Strategy
-- External Library Changes (if any - these are blockers, not to be implemented)
+- External Library Changes (blockers — not to be implemented)
 
-**If no implementation plan found**: Create a comment noting that no plan was found and skip this task. Set status back to "To Do".
+**If no `plan.md` attachment found**: Create a comment noting that no plan was found, suggest running `/plan <taskId>` first, and skip this task. Set status back to "To Do". Do NOT fall back to parsing plan content from comments — the attachment is the source of truth.
 
 #### Step 3b-classify: MANDATORY UI Change Classification
 
@@ -308,16 +306,27 @@ The agent will:
 4. Plan TDD cycles for each implementation unit
 5. Generate the orchestration plan in markdown format
 
-**After receiving the orchestration plan:**
-
-1. **Post to Linear** - Create a comment with the `🎭 Agent Orchestration Plan` on the task
-2. **Follow the plan** - Execute agents in the defined order
-3. **Use TDD strictly** - `shared-tdd-developer` is MANDATORY for ALL code implementation
+**After receiving the orchestration plan, save it as a native `orchestration.md` attachment on the Linear issue (NOT as a comment):**
+
+1. **Check for existing `orchestration.md` attachment** on the task via `mcp__linear__get_issue` (response includes `attachments`).
+   - If one exists, delete it via `mcp__linear__delete_attachment({ id: oldAttachmentId })`. Linear hosts the file natively, so nothing else needs cleanup.
+2. **Write locally**: `Write` the orchestration markdown to `/tmp/claude-plans/<taskId>-orchestration.md`.
+3. **Base64-encode**: `b64=$(base64 -i /tmp/claude-plans/<taskId>-orchestration.md)`.
+4. **Create Linear attachment** via `mcp__linear__create_attachment`:
+   - `issue`: the task/subtask ID
+   - `filename`: `orchestration.md`
+   - `contentType`: `text/markdown`
+   - `title`: `orchestration.md` (exact — used for detection/replacement on the next `/impl` run)
+   - `subtitle`: `Plan orkiestracji wygenerowany przez Claude Code (legacy)`
+   - `base64Content`: the base64 string from step 3
+5. **Clean up** local `/tmp/claude-plans/<taskId>-orchestration.md`.
+6. **Follow the plan** — execute agents in the defined order.
+7. **Use TDD strictly** — `shared-tdd-developer` is MANDATORY for ALL code implementation.
 
 **IMPORTANT**:
 
 1. **`shared-tdd-developer` is MANDATORY** for ALL code implementation tasks
-2. Post the orchestration plan as a comment to the Linear task BEFORE starting implementation
+2. Save the orchestration plan as an `orchestration.md` attachment BEFORE starting implementation — do NOT post it as a comment
 3. Follow the TDD cycle (RED → GREEN → REFACTOR) strictly
 4. Each code change must have a failing test FIRST
 5. **Use Angular 14 patterns** - All agents must use legacy patterns

package/plugins/flow-legacy/skills/linear-suggestion/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: linear-suggestion
 description: Create a Linear issue in the "MobileMS Framework" project with a suggestion for agent or skill improvements.
-allowed-tools: mcp__linear-server__create_issue
+allowed-tools: mcp__linear__save_issue
 ---
 
 # Linear Suggestion

package/plugins/flow-legacy/skills/plan/SKILL.md

@@ -1,9 +1,10 @@
 ---
 name: plan
-description: Create an implementation plan for a Linear task and save it as a comment. Analyzes codebase with Angular 14 legacy patterns, previous commits, and external dependencies.
+description: Create an implementation plan for a Linear task and save it as a `plan.md` attachment. Analyzes codebase with Angular 14 legacy patterns, previous commits, and external dependencies.
 allowed-tools:
   - Bash
   - Read
+  - Write
   - Glob
   - Grep
   - AskUserQuestion
@@ -11,16 +12,19 @@ allowed-tools:
   - TaskUpdate
   - TaskList
   - TaskGet
-  - mcp__linear-server__get_issue
-  - mcp__linear-server__list_issues
-  - mcp__linear-server__list_comments
-  - mcp__linear-server__create_comment
-  - mcp__linear-server__delete_comment
+  - mcp__linear__get_issue
+  - mcp__linear__list_issues
+  - mcp__linear__list_comments
+  - mcp__linear__save_comment
+  - mcp__linear__save_issue
+  - mcp__linear__create_attachment
+  - mcp__linear__delete_attachment
+  - mcp__linear__list_issue_labels
 ---
 
 # Plan Skill
 
-Create an implementation plan for a Linear task and save it as a comment. If the task has subtasks, create individual plans for each subtask.
+Create an implementation plan for a Linear task and save it as a `plan.md` attachment on the issue. If the task has subtasks, create individual `plan.md` attachments on each subtask. After saving the plan, add the `AI Plan` label to the parent task.
 
 ## Execution Checklist
 
@@ -28,8 +32,8 @@ Execute each step in order. Do not skip any step marked as MANDATORY.
 
 - [ ] **1. Fetch Linear task** — get title, description, labels, priority, estimate from MCP Linear server
 - [ ] **2. Fetch subtasks** — check for children; if present, plan each subtask individually
-- [ ] **3. Fetch existing comments** — check parent task and each subtask for existing context
-- [ ] **4. Determine planning needs** — check for existing plans and plan change requests; record old plan comment IDs for replacement; skip tasks with valid plans
+- [ ] **3. Fetch existing attachments and comments** — list `plan.md` attachments and all comments per task/subtask
+- [ ] **4. Determine planning needs** — compare `plan.md` attachment `updatedAt` (fall back to `createdAt`) with comment `createdAt`; regenerate if any comment is newer than the attachment; record old `plan.md` attachment IDs for replacement
 - [ ] **5. Analyze previous commits** — `git log --all --grep="<taskId>"` for each task/subtask
 - [ ] **6. Analyze staged changes** — `git status` and `git diff --cached` for work in progress
 - [ ] **7. MANDATORY: Analyze codebase** — explore affected files, patterns, dependencies, and test coverage
@@ -38,9 +42,10 @@ Execute each step in order. Do not skip any step marked as MANDATORY.
 - [ ] **10. Create implementation plans** — generate structured plans per task/subtask with all required sections, using Angular 14 patterns
 - [ ] **11. MANDATORY: Write plans in Polish** — all plan content must be in Polish language
 - [ ] **12. Show plans to user** — present plans for review and approval before saving
-- [ ] **13. MANDATORY: Confirm old plan deletion** — if replacing existing plans, ask user to confirm deletion of old plan comments before proceeding
-- [ ] **14. Delete old plan comments and save new ones** — delete outdated plan comments from Linear, then post new plans via MCP
-- [ ] **15. Confirm to user** — list saved plans with summaries and Linear links
+- [ ] **13. MANDATORY: Confirm old plan deletion** — if replacing existing `plan.md`, ask user to confirm deletion of old attachment before proceeding
+- [ ] **14. Save plan as native Linear attachment** — base64-encode `plan.md` content and upload via `mcp__linear__create_attachment` (Linear hosts the file; no external storage)
+- [ ] **15. MANDATORY: Add "AI Plan" label** — ensure `AI Plan` label exists on the team and apply it to the invoked issue (the `linearTaskId` passed to `/plan` — parent task or subtask, whichever was called)
+- [ ] **16. Confirm to user** — list saved plans with summaries and Linear links
 
 ### Task Progress Tracking
 
@@ -152,60 +157,45 @@ Use the MCP Linear server to check if the task has subtasks (children). If subta
 
 **Important**: If subtasks exist, you will create individual plans for each subtask, not for the parent task.
 
-### Step 3: Fetch Task Comments
+### Step 3: Fetch Task Attachments and Comments
 
-Use the MCP Linear server to fetch all existing comments for:
+Use the MCP Linear server to fetch, for the parent task and each subtask:
 
-- The parent task
-- Each subtask (if subtasks exist)
-
-This helps to:
-
-- Understand any additional context or discussions
-- Avoid duplicating information already discussed
-- Identify any blockers or dependencies mentioned
+- Attachments via `mcp__linear__get_issue` (attachments included in response) — look for one titled exactly `plan.md`
+- Comments via `mcp__linear__list_comments` — keep `id`, `createdAt`, body text
 
 ### Step 3a: Determine Which Tasks Need Planning
 
-For each task/subtask, analyze the comments to determine if a new plan should be created:
-
-#### Check for existing plan:
+For each task/subtask, use the **attachment mtime vs comment ctime** rule:
 
-Look for comments containing:
+#### Inputs per task
 
-- `## Implementation Plan` (for parent tasks)
-- `## Implementation Plan for Subtask` (for subtasks)
+- `planAttachment`: the Linear attachment titled `plan.md` (or `null`)
+- `planAttachment.updatedAt` (fall back to `createdAt`): when the plan was last written
+- `comments`: list of all comments with `createdAt`
 
-#### Decision logic:
+#### Decision logic
 
 **Create a NEW plan if:**
 
-1. **No plan exists**: The task/subtask has no comment with an implementation plan
-2. **Plan change requested**: An existing plan exists, BUT there is a **newer comment** (created after the plan) that requests changes to the plan. Look for keywords like:
-   - "zmień plan" / "change plan"
-   - "zaktualizuj plan" / "update plan"
-   - "popraw plan" / "fix plan"
-   - "nowy plan" / "new plan"
-   - "proszę o zmianę" / "please change"
-   - "do zmiany" / "needs change"
-   - "uwagi do planu" / "comments on plan"
+1. `planAttachment == null`, OR
+2. there is at least one comment where `comment.createdAt > planAttachment.updatedAt`
 
 **SKIP planning if:**
 
-1. **Plan exists and no change requested**: The task/subtask already has an implementation plan AND there are no newer comments requesting changes
-2. **Plan exists with only acknowledgment comments**: Newer comments exist but they are just acknowledgments (e.g., "ok", "dzięki", "rozumiem")
+1. `planAttachment` exists AND no comment is newer than it.
 
-#### Output:
+#### Secondary signal (optional)
 
-Create a list of tasks/subtasks that need planning:
+If `planAttachment` exists and no comment is newer than it, but the user's latest prompt mentions plan-change keywords ("zmień plan", "zaktualizuj plan", "popraw plan", "nowy plan", "uwagi do planu"), ask the user explicitly — do **not** regenerate silently on keyword alone.
 
-- `tasksNeedingPlan`: Array of task IDs that need a new or updated plan
-- `tasksWithExistingPlan`: Array of task IDs that already have valid plans (skip these)
-- `oldPlanCommentIds`: Map of task ID → comment ID for existing plan comments that will be replaced (needed for deletion in Step 9)
+#### Output:
 
-**Important**: When a plan change is requested, record the **comment ID** of the existing plan comment. This ID is needed later to delete the old plan before saving the new one.
+- `tasksNeedingPlan`: Array of task IDs that need a new or updated plan
+- `tasksWithExistingPlan`: Array of task IDs with up-to-date plans
+- `oldPlanAttachments`: Map of task ID → `attachmentId` for plans being replaced
 
-**Important**: If ALL tasks already have valid plans and no changes are requested, inform the user and ask if they want to regenerate plans anyway.
+**Important**: If ALL tasks already have up-to-date plans, inform the user and ask if they want to regenerate anyway.
 
 ### Step 4: Analyze Previous Commits
 
@@ -524,65 +514,99 @@ _Plan generated by Claude Code (flow-legacy)_
 _Plan generated by Claude Code (flow-legacy)_
 ```
 
-### Step 9: Confirm and Delete Old Plan Comments
+### Step 9: Confirm and Delete Old Plan Attachments
 
-**This step applies only when replacing existing plans** (i.e., `oldPlanCommentIds` from Step 3a is not empty).
+**This step applies only when replacing existing plans** (`oldPlanAttachments` from Step 3a is not empty).
 
-Before saving new plans, ask the user to confirm deletion of old plan comments:
+Before saving new plans, ask the user to confirm deletion of old `plan.md` attachments:
 
 ```markdown
 ## Zastąpienie istniejących planów
 
-Następujące komentarze z planami zostaną usunięte i zastąpione nowymi:
+Następujące załączniki `plan.md` zostaną usunięte i zastąpione nowymi:
 
-| Task      | Stary komentarz (ID) |
+| Task      | Stary załącznik (ID) |
 | --------- | -------------------- |
-| <task-id> | <comment-id>         |
+| <task-id> | <attachment-id>      |
 
 Czy potwierdzasz usunięcie starych planów i zapisanie nowych?
 ```
 
-Use `AskUserQuestion` tool with options:
+Use `AskUserQuestion` with options:
 
 - "Tak, usuń stare plany i zapisz nowe" (Recommended)
-- "Nie, zachowaj stare plany (zapisz nowe obok)"
 - "Anuluj"
 
-**If user confirms deletion:**
+**If user confirms:**
 
-1. For each task in `oldPlanCommentIds`, delete the old plan comment using `mcp__linear-server__delete_comment`
-2. If `delete_comment` is not available, add a strikethrough header to the old comment body: `~~## Implementation Plan~~ (Zastąpiony nowym planem)` — use `mcp__linear-server__update_comment` as fallback
-3. Then proceed to save new plan comments
+1. For each entry in `oldPlanAttachments`, delete the Linear attachment via `mcp__linear__delete_attachment({ id: attachmentId })`.
+2. Proceed to Step 9a.
 
-**If user chooses to keep old plans:**
+**If user cancels:** Stop the process, do not save any plans.
 
-- Skip deletion, save new plans as additional comments (old plans remain)
+### Step 9a: Save Plan as Native Linear Attachment
 
-**If user cancels:**
+For each task that needs planning, upload the plan content directly to Linear (no external storage).
 
-- Stop the entire process, do not save any plans
+#### 9a.1 — Write `plan.md` locally
 
-### Step 9a: Save New Plans as Comments
+```bash
+mkdir -p /tmp/claude-plans
+```
 
-Use the MCP Linear server to create comments:
+Use `Write` to save plan content to `/tmp/claude-plans/<taskId>-plan.md`.
 
-#### If NO subtasks:
+#### 9a.2 — Base64-encode
 
-- Create a single comment on the parent task with the implementation plan
+```bash
+b64=$(base64 -i /tmp/claude-plans/<taskId>-plan.md)
+```
 
-#### If subtasks exist:
+On macOS `base64 -i <file>` outputs without line-wrapping. On Linux, pipe through `tr -d '\n'` if needed.
+
+#### 9a.3 — Create Linear attachment
+
+Call `mcp__linear__create_attachment` with:
+
+- `issue`: the task/subtask ID
+- `filename`: `plan.md`
+- `contentType`: `text/markdown`
+- `title`: `plan.md` (exact — used for detection in Step 3 and by `/impl`)
+- `subtitle`: `Plan wygenerowany przez Claude Code (legacy)`
+- `base64Content`: the base64 string from 9a.2
+
+Linear hosts the file on its own infrastructure.
+
+#### 9a.4 — Clean up local file
+
+Delete `/tmp/claude-plans/<taskId>-plan.md` after the attachment is created. `/push` does NOT delete Linear attachments — they stay on the issue.
+
+#### Scope rule
+
+- No subtasks → attach `plan.md` to parent.
+- Has subtasks → attach `plan.md` to each subtask needing planning. Do NOT attach on the parent.
+
+### Step 9b: Add "AI Plan" Label
+
+Apply the `AI Plan` label to the **invoked issue** — i.e. the `linearTaskId` passed to `/plan`:
+
+- `/plan MOB-123` (parent) → label on `MOB-123`. Subtasks receive `plan.md` attachments but no label.
+- `/plan MOB-123-1` (subtask) → label on `MOB-123-1` directly; parent untouched.
+
+**`AI Plan` is a workspace-level (organization-wide) label that already exists** — do NOT create it.
 
-- Create a comment on **each subtask** with its specific implementation plan
-- Do NOT create a plan comment on the parent task (subtask plans are sufficient)
+1. Look up label `AI Plan` via `mcp__linear__list_issue_labels` (workspace-wide). If not found for any reason, surface the error — do NOT create a team-scoped duplicate.
+2. Apply via `mcp__linear__save_issue({ id: invokedTaskId, labelIds: [...existingLabelIds, aiPlanLabelId] })`. Preserve existing labels. Skip if already present.
+3. If label operations fail, surface the error but do not roll back the attachment.
 
 ### Step 10: Confirm to User
 
-After successfully saving the plans, confirm to the user:
+After saving:
 
-- List all tasks/subtasks where plans were saved
-- Show a summary of each plan
-- Provide Linear task links
-- Mention any important considerations or questions
+- List all tasks/subtasks where `plan.md` was attached (with Linear attachment URL)
+- Show plan summaries
+- Confirm `AI Plan` label added to parent task
+- Provide Linear links
 
 ## Guidelines
 
@@ -598,11 +622,12 @@ After successfully saving the plans, confirm to the user:
 10. **Keep subtask plans focused**: Each subtask plan should only cover that subtask's scope
 11. **Identify cross-subtask dependencies**: Note which subtasks depend on or block others
 12. **Identify external library changes**: Always check if task requires changes in `@smartsoft001` (repo: `../smartsoft001`) or `@smartsoft001-mobilems` (repo: `../mobilems-framework`). Mark these as separate process items, not part of current implementation
-13. **Skip tasks with existing plans**: Only create plans for tasks that don't have a plan yet, or where a newer comment requests plan changes. Don't regenerate plans unnecessarily.
-14. **Detect plan change requests**: Look for keywords in newer comments that indicate a plan change is needed (e.g., "zmień plan", "zaktualizuj plan", "popraw plan", "uwagi do planu")
+13. **Skip tasks with up-to-date plans**: Only regenerate when the `plan.md` attachment is missing or stale (any comment newer than `plan.md.updatedAt`).
+14. **Mtime rule is authoritative**: Regeneration driven by attachment `updatedAt` vs comment `createdAt`. Keyword detection triggers an explicit user confirmation only — never a silent regen.
 15. **Use Angular 14 patterns**: Always plan for `*ngIf`/`*ngFor`, constructor DI, `@Input()`/`@Output()`, BehaviorSubject - NOT signals, `@if`/`@for`, or `inject()`
-16. **Delete old plans when replacing**: When creating a replacement plan, always ask user to confirm deletion of the old plan comment. Delete old comment before saving new one to keep Linear comments clean. Record old plan comment IDs during Step 3a for use in Step 9
+16. **Delete old plans cleanly**: When replacing, ask user to confirm, then delete the old Linear attachment via `mcp__linear__delete_attachment`.
+17. **Always add "AI Plan" label**: After saving plan attachments, apply the workspace-level `AI Plan` label (already configured organization-wide — do NOT create a team-scoped duplicate) to the invoked issue.
 
 ---
 
-**Important**: Before saving the plans, show them to the user for review and approval.
+**Important**: Before saving the plans as attachments, show them to the user for review and approval. The plan content is written to `/tmp/claude-plans/<taskId>-plan.md`, base64-encoded, and uploaded as a native Linear attachment via `mcp__linear__create_attachment`. After that, the `AI Plan` label is applied to the invoked issue.

package/plugins/flow-legacy/skills/push/SKILL.md

@@ -12,12 +12,12 @@ allowed-tools:
   - TaskUpdate
   - TaskList
   - TaskGet
-  - mcp__linear-server__get_issue
-  - mcp__linear-server__list_issues
-  - mcp__linear-server__list_comments
-  - mcp__linear-server__create_comment
-  - mcp__linear-server__update_issue
-  - mcp__linear-server__list_issue_statuses
+  - mcp__linear__get_issue
+  - mcp__linear__list_issues
+  - mcp__linear__list_comments
+  - mcp__linear__save_comment
+  - mcp__linear__save_issue
+  - mcp__linear__list_issue_statuses
 ---
 
 # Push Skill