@smartsoft001-mobilems/claude-plugins 2.71.0 → 2.73.0

package/plugins/flow-legacy/.claude-plugin/README.md

@@ -1,6 +1,6 @@
 # Flow-Legacy Plugin for Claude Code
 
-Development flow commands for **legacy Angular 14 projects** with Linear-driven workflow.
+Development flow skills for **legacy Angular 14 projects** with Linear-driven workflow.
 
 ## Target Projects
 
@@ -22,10 +22,10 @@ This plugin is designed for older MobileMS projects using:
 | Components | NgModules | Standalone |
 | Nx packages | `@nrwl/*` | `@nx/*` |
 
-## Commands
+## Workflow Skills
 
-| Command | Description |
-|---------|-------------|
+| Skill | Description |
+|-------|-------------|
 | `/commit` | Create conventional commit based on Linear task |
 | `/impl` | Implement plans from Linear task comments |
 | `/plan` | Create implementation plan and save to Linear |
@@ -67,15 +67,15 @@ Configure these in your `.mcp.json`:
 - Nx commands (test, lint, build)
 - Linear API (read/write issues, comments)
 - Playwright (screenshots)
-- Internal skills
+- Utility skills
 
 ### Requires Confirmation (ask)
-- Flow commands (/commit, /impl, /plan, /push)
+- Workflow skills (/commit, /impl, /plan, /push)
 - `git commit` - creating commits
 - `git push` - pushing to remote
 - `gh pr create` - creating pull requests
 
-## Skills
+## Utility Skills
 
 | Skill | Description |
 |-------|-------------|

package/plugins/flow-legacy/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "flow-legacy",
-  "description": "Development flow commands for legacy Angular 14 projects with Linear-driven workflow",
-  "version": "2.71.0"
+  "description": "Development flow skills for legacy Angular 14 projects with Linear-driven workflow",
+  "version": "2.73.0"
 }

package/plugins/flow-legacy/.claude-plugin/settings.template.json

@@ -38,6 +38,7 @@
       "mcp__linear-server__list_issues",
       "mcp__linear-server__list_comments",
       "mcp__linear-server__create_comment",
+      "mcp__linear-server__delete_comment",
       "mcp__linear-server__update_issue",
       "mcp__linear-server__list_issue_statuses",
       "mcp__linear-server__create_issue",
@@ -72,4 +73,4 @@
   "enabledPlugins": {
     "flow-legacy@mobilems": true
   }
-}
+}

package/plugins/flow-legacy/{commands/commit.md → skills/commit/SKILL.md}

@@ -1,4 +1,21 @@
-# Commit Command
+---
+name: commit
+description: Create a conventional commit message based on Linear task and staged changes. Fetches task details, analyzes changes, generates commit message, and optionally runs parallelization analysis.
+allowed-tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+  - AskUserQuestion
+  - TaskCreate
+  - TaskUpdate
+  - TaskList
+  - TaskGet
+  - mcp__linear-server__get_issue
+  - mcp__linear-server__list_comments
+---
+
+# Commit Skill
 
 Create a conventional commit message based on Linear task and staged changes.
 
@@ -12,6 +29,41 @@ Create a conventional commit message based on Linear task and staged changes.
 
 - `linearTaskId` - Linear task ID (e.g., ENG-123)
 
+## Execution Checklist
+
+Execute each step in order. Do not skip any step marked as MANDATORY.
+
+- [ ] **1. Fetch Linear task** — get title, description, labels/type from MCP Linear server
+- [ ] **2. Analyze staged changes** — run `git diff --cached` to understand scope
+- [ ] **3. Verify completeness** — compare task requirements with staged changes; if incomplete, ask user whether to continue or stop
+- [ ] **4. Read commitlint config** — read `commitlint.config.js` for valid scopes and format
+- [ ] **5. Generate commit message** — draft `<type>(<scope>): <subject>` with body and `Refs: <linearTaskId>`
+- [ ] **6. Show message to user** — present commit message for approval before proceeding
+- [ ] **7. MANDATORY: Pre-commit preparation** — run `nvm use 18` (legacy Node.js version)
+- [ ] **8. Create commit** — execute `git commit` with the approved message
+- [ ] **9. Parallelization analysis (optional)** — fetch Linear comments, search for orchestration plan, delegate to `shared-parallelization-analyzer` if found
+
+### Task Progress Tracking
+
+**MANDATORY**: Use Claude Code's built-in task tracking to provide real-time progress visibility.
+
+**At skill start**: Create tasks for each checklist step using `TaskCreate`:
+
+```
+TaskCreate({
+  subject: "Fetch Linear task",
+  description: "Get title, description, labels/type from MCP Linear server",
+  activeForm: "Fetching Linear task"
+})
+```
+
+**During execution**:
+
+- Before starting a step → `TaskUpdate({ taskId, status: "in_progress" })`
+- After completing a step → `TaskUpdate({ taskId, status: "completed" })`
+
+**At checkpoints**: Use `TaskList` to review overall progress before presenting status to user.
+
 ## Instructions
 
 You are tasked with creating a git commit based on a Linear task and staged changes.

package/plugins/flow-legacy/{commands/impl.md → skills/impl/SKILL.md}

@@ -1,7 +1,95 @@
-# Implementation Command
+---
+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.
+allowed-tools:
+  - Bash
+  - Read
+  - Edit
+  - Write
+  - Glob
+  - Grep
+  - AskUserQuestion
+  - Task
+  - TaskCreate
+  - 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
+---
+
+# Implementation Skill
 
 Implement plans from Linear task comments. For tasks with subtasks, iteratively implement each subtask that is in "To Do" status.
 
+## Execution Checklist
+
+Execute each step in order. Do not skip any step marked as MANDATORY.
+
+### Initial Setup
+
+- [ ] **1. Fetch task and subtasks** — delegate to `shared-linear-subtask-iterator` agent
+
+### 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
+- [ ] **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
+- [ ] **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)
+- [ ] **9. MANDATORY: Use Angular 14 patterns** — `*ngIf`/`*ngFor`, constructor DI, `@Input()`/`@Output()`, BehaviorSubject — NEVER signals, `@if`/`@for`, `inject()`
+- [ ] **10. Verify implementation** — run tests, lint, build check
+- [ ] **11. Capture "after" screenshots** — if `UI_CHANGE_REQUIRED: YES`, capture + post comparison to Linear + cleanup
+- [ ] **12. MANDATORY: Screenshot verification** — output `SCREENSHOT_REQUIREMENT_MET: YES/NO`, block if missing
+- [ ] **13. Create completion comment** — delegate to `shared-impl-reporter`, post to Linear
+- [ ] **14. MANDATORY: Write reports in Polish** — all Linear comments must be in Polish language
+- [ ] **15. Update status** — delegate to `shared-linear-subtask-iterator` for status determination
+- [ ] **16. Agent evolution** — if user confirmed feedback, delegate to `shared-agent-evolver`
+- [ ] **17. Pause for user confirmation** — ALWAYS wait before proceeding to next subtask
+
+### Finalization
+
+- [ ] **18. Final summary** — present summary of all subtasks with statuses
+- [ ] **19. ALWAYS pause** — wait for user confirmation at end
+
+### Task Progress Tracking
+
+**MANDATORY**: Use Claude Code's built-in task tracking to provide real-time progress visibility.
+
+**At skill start**: Create tasks for the initial setup and each subtask processing round using `TaskCreate`:
+
+```
+TaskCreate({
+  subject: "Fetch task and subtasks",
+  description: "Delegate to shared-linear-subtask-iterator agent",
+  activeForm: "Fetching task and subtasks"
+})
+```
+
+**Per subtask**: Create a parent task for the subtask, then child tasks for each step:
+
+```
+TaskCreate({
+  subject: "Implement subtask MOB-123",
+  description: "Full implementation cycle: classify → orchestrate → implement → verify",
+  activeForm: "Implementing subtask MOB-123"
+})
+```
+
+**During execution**:
+
+- Before starting a step → `TaskUpdate({ taskId, status: "in_progress" })`
+- After completing a step → `TaskUpdate({ taskId, status: "completed" })`
+- At 3x3 checkpoints → `TaskList` to show progress overview
+
+**At pause points**: Use `TaskList` to present a clear status summary to the user before waiting for confirmation.
+
 ## Role
 
 **You are a highly experienced senior TypeScript developer** with:
@@ -30,6 +118,7 @@ You implement code that is:
 **ALWAYS use these patterns in legacy projects:**
 
 ### Components
+
 ```typescript
 // CORRECT (Angular 14)
 @Component({
@@ -45,7 +134,7 @@ export class ExampleComponent implements OnInit {
 
   constructor(
     private readonly dataService: DataService,
-    private readonly router: Router
+    private readonly router: Router,
   ) {}
 
   ngOnInit(): void {
@@ -61,13 +150,12 @@ export class ExampleComponent implements OnInit {
 ```
 
 ### Templates
+
 ```html
 <!-- CORRECT (Angular 14) -->
 <div *ngIf="isLoading">Loading...</div>
 <ul *ngIf="items.length > 0">
-  <li *ngFor="let item of items; trackBy: trackByFn">
-    {{ item.name }}
-  </li>
+  <li *ngFor="let item of items; trackBy: trackByFn">{{ item.name }}</li>
 </ul>
 
 <!-- WRONG (Angular 20+ - DO NOT USE) -->
@@ -76,6 +164,7 @@ export class ExampleComponent implements OnInit {
 ```
 
 ### Services
+
 ```typescript
 // CORRECT (Angular 14)
 @Injectable({ providedIn: 'root' })
@@ -295,6 +384,7 @@ Use tools:
 - `Glob` and `Grep` for additional exploration if needed
 
 **CRITICAL - Angular 14 Pattern Enforcement:**
+
 - ALWAYS use `*ngIf`, `*ngFor` in templates
 - ALWAYS use constructor injection
 - ALWAYS use `@Input()`, `@Output()` decorators
@@ -313,6 +403,7 @@ Use tools:
 3. ✅ [Change 3 description] - `path/to/file3.ts`
 
 ### Angular 14 Patterns Used
+
 - Constructor DI: ✅
 - *ngIf/*ngFor: ✅
 - @Input/@Output: ✅
@@ -332,6 +423,26 @@ Use tools:
 Continue? (yes/no/adjust)
 ```
 
+**Feedback Collection for Agent Evolution:**
+
+During 3x3 checkpoints, when the user provides corrections or suggestions about coding patterns, implementation approach, or agent behavior — **ASK the user explicitly** if they want to create a Linear issue for the improvement.
+
+**When user provides a correction or pattern suggestion, ASK:**
+
+```
+🔄 Detected potential improvement suggestion:
+"[summary of user's correction]"
+
+Would you like to create a Linear issue for this pattern improvement?
+- Yes - File as Linear issue in "MobileMS Framework"
+- No - Note for this session only
+- Skip - Ignore this feedback
+```
+
+**Only feedback confirmed with "Yes"** should be collected as **evolution feedback items** and processed in Step 3g-evolve via `linear-suggestion` skill.
+
+Look for signals like: universal language ("always", "never"), pattern-level corrections, or explicit requests to update agent behavior.
+
 #### Step 3e: Verify Implementation
 
 After implementing:
@@ -408,6 +519,35 @@ The agent will determine the correct status and provide MCP command to execute.
 
 **Execute the status update** via MCP Linear server.
 
+#### Step 3g-evolve: Agent Evolution Checkpoint
+
+**Prerequisites**: Only execute this step if user confirmed at least one feedback item with "Yes" during 3x3 checkpoints.
+
+**Delegate to `shared-agent-evolver` agent:**
+
+```
+Analyze feedback from current subtask implementation:
+- Subtask ID: [current subtask ID]
+- User-confirmed corrections: [list of feedback items where user answered "Yes"]
+- Files that were implemented: [list of files modified/created]
+- Patterns the user corrected or suggested: [specific corrections]
+```
+
+The agent will:
+
+1. Classify each feedback item (IGNORE / EVOLVE_PATTERN / EVOLVE_RULE / EVOLVE_TEMPLATE / CREATE_AGENT / UPDATE_WORKFLOW)
+2. Generate proposals for non-IGNORE items
+3. File each proposal as a Linear issue in "MobileMS Framework" via `linear-suggestion` skill
+4. Return Evolution Report with created issue IDs
+
+**IMPORTANT**:
+
+- Agent files are NOT modified directly — proposals are filed as Linear issues for manual review
+- **Only process feedback explicitly confirmed by user** — do not auto-collect without asking
+- If no user-confirmed feedback was collected during this subtask, skip this step
+- This step runs BEFORE the subtask pause (Step 3h) so evolution is complete before moving on
+- If Linear issue creation fails, continue silently — do not block the workflow
+
 #### Step 3h: Pause After Subtask Completion
 
 **Delegate to `shared-linear-subtask-iterator` agent:**
@@ -460,13 +600,14 @@ To Do → In Progress → In Review (if completed)
 
 **ALWAYS stop and wait for user confirmation at these points:**
 
-| Pause Point          | When                                | What to Show                        |
-| -------------------- | ----------------------------------- | ----------------------------------- |
-| **3x3 Checkpoint**   | After every 3 changes               | Summary of 3 changes + next 3 steps |
-| **Subtask Complete** | After finishing each subtask        | Subtask summary + next subtask info |
-| **Task Complete**    | After finishing all subtasks        | Final summary with all results      |
-| **Blocker Found**    | When external dependency found      | Blocker details + options           |
-| **Error/Issue**      | When unexpected problem occurs      | Error details + proposed solution   |
+| Pause Point          | When                                | What to Show                              |
+| -------------------- | ----------------------------------- | ----------------------------------------- |
+| **3x3 Checkpoint**   | After every 3 changes               | Summary of 3 changes + next 3 steps       |
+| **Subtask Complete** | After finishing each subtask        | Subtask summary + next subtask info       |
+| **Task Complete**    | After finishing all subtasks        | Final summary with all results            |
+| **Blocker Found**    | When external dependency found      | Blocker details + options                 |
+| **Error/Issue**      | When unexpected problem occurs      | Error details + proposed solution         |
+| **Agent Evolution**  | After subtask / after final summary | Evolution report with filed Linear issues |
 
 **Never proceed automatically** - always wait for explicit user confirmation before:
 
@@ -489,6 +630,7 @@ To Do → In Progress → In Review (if completed)
 11. **Follow existing patterns**: Match the codebase conventions when implementing
 12. **Commit changes**: After each subtask implementation, consider if a commit is needed
 13. **Ask for clarification**: If implementation plan is unclear, ask before proceeding
+14. **Ask before collecting feedback for agent evolution**: When user provides corrections or suggestions during implementation, **explicitly ask** if they want to create a Linear issue for the improvement. Only user-confirmed feedback (answered "Yes") should be processed at evolution checkpoints (Step 3g-evolve) via `shared-agent-evolver` agent.
 
 ---
 

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

@@ -1,16 +1,16 @@
 ---
 name: linear-suggestion
-description: Create a Linear issue in the "MobileMS Framework" project with a suggestion for agent, command, or skill improvements.
+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
 ---
 
 # Linear Suggestion
 
-Create a Linear issue in the **MobileMS Framework** project containing a suggestion for improving agent definitions, commands, or skills. Used by automated analysis agents to propose changes without blocking the workflow.
+Create a Linear issue in the **MobileMS Framework** project containing a suggestion for improving agent definitions or skills. Used by automated analysis agents to propose changes without blocking the workflow.
 
 ## When to Use
 
-- When an automated agent (e.g., `shared-parallelization-analyzer`) identifies a recurring pattern that could improve an agent, command, or skill
+- When an automated agent (e.g., `shared-parallelization-analyzer`) identifies a recurring pattern that could improve an agent or skill
 - When proposing orchestrator rule changes based on parallelization analysis
 - When any non-interactive process needs to suggest framework improvements
 
@@ -18,13 +18,13 @@ Create a Linear issue in the **MobileMS Framework** project containing a suggest
 
 The invoking agent must provide:
 
-| Parameter     | Required | Description                                                     |
-| ------------- | -------- | --------------------------------------------------------------- |
-| `title`       | YES      | Short summary of the suggestion (max 100 chars)                 |
-| `description` | YES      | Full markdown description with rationale and proposed changes    |
+| Parameter     | Required | Description                                                                   |
+| ------------- | -------- | ----------------------------------------------------------------------------- |
+| `title`       | YES      | Short summary of the suggestion (max 100 chars)                               |
+| `description` | YES      | Full markdown description with rationale and proposed changes                 |
 | `source`      | YES      | Agent that generated the suggestion (e.g., `shared-parallelization-analyzer`) |
-| `targetFile`  | NO       | Path to the file to be modified (e.g., `agents/shared-impl-orchestrator.md`) |
-| `category`    | NO       | One of: `OPTIMIZATION`, `NEW_RULE`, `PATTERN_UPDATE`, `BUG_FIX` |
+| `targetFile`  | NO       | Path to the file to be modified (e.g., `agents/shared-impl-orchestrator.md`)  |
+| `category`    | NO       | One of: `OPTIMIZATION`, `NEW_RULE`, `PATTERN_UPDATE`, `BUG_FIX`               |
 
 ## Issue Format
 
@@ -129,4 +129,4 @@ Linear issue created:
 - ID: MOB-815
 - Title: [Agent Suggestion] Add parallel scaffolding rule to orchestrator
 - URL: https://linear.app/mobilems/issue/MOB-815
-```
+```

package/plugins/flow-legacy/{commands/plan.md → skills/plan/SKILL.md}

@@ -1,7 +1,68 @@
-# Plan Create Command
+---
+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.
+allowed-tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+  - AskUserQuestion
+  - TaskCreate
+  - 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
+---
+
+# 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.
 
+## Execution Checklist
+
+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
+- [ ] **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
+- [ ] **8. MANDATORY: Verify Angular 14 patterns** — confirm `*ngIf`/`*ngFor`, constructor DI, `@Input()`/`@Output()`, BehaviorSubject in existing code
+- [ ] **9. Analyze external library deps** — check if `@smartsoft001` or `@smartsoft001-mobilems` changes are needed (mark as separate process)
+- [ ] **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
+
+### Task Progress Tracking
+
+**MANDATORY**: Use Claude Code's built-in task tracking to provide real-time progress visibility.
+
+**At skill start**: Create tasks for each checklist step using `TaskCreate`:
+
+```
+TaskCreate({
+  subject: "Fetch Linear task",
+  description: "Get title, description, labels, priority, estimate from MCP Linear server",
+  activeForm: "Fetching Linear task"
+})
+```
+
+**During execution**:
+
+- Before starting a step → `TaskUpdate({ taskId, status: "in_progress" })`
+- After completing a step → `TaskUpdate({ taskId, status: "completed" })`
+
+**Before user review**: Use `TaskList` to show progress overview before presenting plans for approval.
+
 ## Role
 
 **You are a highly experienced software architect** with:
@@ -38,17 +99,20 @@ You create plans that are:
 When creating plans, always use these legacy patterns:
 
 ### Components
+
 - Use `@Component` with `NgModule` (NOT standalone)
 - Use `*ngIf` and `*ngFor` (NOT `@if` and `@for`)
 - Use constructor injection (NOT `inject()`)
 - Use `@Input()` and `@Output()` decorators (NOT `input()`, `output()`)
 
 ### Services
+
 - Use `BehaviorSubject` and `Observable` (NOT signals)
 - Use constructor injection
 - Use `@Injectable({ providedIn: 'root' })` or module providers
 
 ### State Management
+
 - Use NgRx Store/Effects or BehaviorSubject patterns
 - NO signals, computed(), or effect()
 
@@ -126,6 +190,9 @@ Create a list of tasks/subtasks that need planning:
 
 - `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)
+
+**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.
 
 **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.
 
@@ -185,6 +252,7 @@ Use tools like:
 - `Read` to understand specific implementations
 
 **Important**: Always check for Angular 14 patterns in existing code:
+
 - Look for `*ngIf`, `*ngFor` usage (NOT `@if`, `@for`)
 - Look for constructor injection patterns
 - Look for `@Input()`, `@Output()` decorators
@@ -297,6 +365,7 @@ Create a **separate plan for each subtask** that includes:
 [Key findings from codebase exploration]
 
 **Angular 14 patterns to follow:**
+
 - Use `*ngIf` / `*ngFor` for control flow
 - Use constructor injection for DI
 - Use `@Input()` / `@Output()` for component communication
@@ -393,6 +462,7 @@ _Plan generated by Claude Code (flow-legacy)_
 [Findings specific to this subtask]
 
 **Angular 14 patterns to follow:**
+
 - Use `*ngIf` / `*ngFor` for control flow
 - Use constructor injection for DI
 - Use `@Input()` / `@Output()` for component communication
@@ -443,7 +513,45 @@ _Plan generated by Claude Code (flow-legacy)_
 _Plan generated by Claude Code (flow-legacy)_
 ```
 
-### Step 9: Save Plans as Comments
+### Step 9: Confirm and Delete Old Plan Comments
+
+**This step applies only when replacing existing plans** (i.e., `oldPlanCommentIds` from Step 3a is not empty).
+
+Before saving new plans, ask the user to confirm deletion of old plan comments:
+
+```markdown
+## Zastąpienie istniejących planów
+
+Następujące komentarze z planami zostaną usunięte i zastąpione nowymi:
+
+| Task      | Stary komentarz (ID) |
+| --------- | -------------------- |
+| <task-id> | <comment-id>         |
+
+Czy potwierdzasz usunięcie starych planów i zapisanie nowych?
+```
+
+Use `AskUserQuestion` tool with options:
+
+- "Tak, usuń stare plany i zapisz nowe" (Recommended)
+- "Nie, zachowaj stare plany (zapisz nowe obok)"
+- "Anuluj"
+
+**If user confirms deletion:**
+
+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
+
+**If user chooses to keep old plans:**
+
+- Skip deletion, save new plans as additional comments (old plans remain)
+
+**If user cancels:**
+
+- Stop the entire process, do not save any plans
+
+### Step 9a: Save New Plans as Comments
 
 Use the MCP Linear server to create comments:
 
@@ -482,6 +590,7 @@ After successfully saving the plans, confirm to the user:
 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")
 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
 
 ---