wb-flow 1.0.0-r01

package/templates/commands/wbValid/wbValid_template.md

@@ -0,0 +1,142 @@
+# /wbValid: Execution Template
+
+<!-- HELP_GATE_START -->
+## Help intercept (handle FIRST — before any other action)
+
+**If `$ARGUMENTS` contains `--help`, `-h`, or `--h`** (case-insensitive, anywhere in the args), DO NOT execute the command's normal procedure. Instead:
+
+1. Output the **HELP BLOCK** below verbatim (rendered as markdown).
+2. Stop. Do not perform any file reads, writes, or other tool calls.
+
+### HELP BLOCK — `/wbValid`
+
+## The Command Forms
+
+```
+/wbValid <path_to_plan.md>               # State what validation is needed
+/wbValid <path_to_plan.md> *             # Validate all tasks that are Done but not Valid
+/wbValid <path_to_plan.md> --id=1,2,3    # Validate specifically tasks 1, 2, and 3
+/wbValid <path_to_plan.md> --p=P1          # Validate all tasks with P1 priority
+/wbValid <path_to_plan.md> --done=true     # Validate tasks that are already done
+/wbValid <path_to_plan.md> --worker=Gemini # Validate tasks worked on by Gemini
+/wbValid <path_to_plan.md> --id=5 --open   # Set task 5 Valid column to ⬜
+/wbValid <path_to_plan.md> --id=* --can    # Set all tasks Valid column to 🚫 Cancelled
+```
+
+**Shorthand Pathing:** You can pass just the filename (e.g., `plan_core2_20260503.md`). The AI will infer the package (`core2`) and the date (`2026/05/03`) to construct the full path: `<pkg>/.wb/workflows/reports/<YYYY>/<MM>/<DD>/plans/<filename>`.
+
+## When to run
+- After a Worker model has executed `/wbWork` and marked tasks as `✅` Done.
+- Use it to act as the **Validator** model.
+
+## The Output
+`/wbValid` reads the Worker's task report, checks the codebase to ensure the work actually meets the acceptance criteria, and appends its validation findings to the bottom of the Worker's task report. It then updates the `☐ Valid` column to `✅` in the parent plan file.
+
+<!-- FLAGS_TABLE_START -->
+## Flags & shortcuts
+
+| `--id`, `--p`, `--done`, etc. | `-i`, etc. | Universal Column Filtering. Targets tasks based on any column in the plan table (supports `=, >, <, !=, *, &&, ||`). |
+| `--open` | `-o` | Sets `☐ Valid` state to `⬜` (Open). Overrides validation execution. |
+| `--def` | `-d` | Sets `☐ Valid` state to `⏸️ Deferred`. Overrides validation execution. |
+| `--can` | `-c` | Sets `☐ Valid` state to `🚫 Cancelled`. Overrides validation execution. |
+| `--help` | `-h` | Prints this help block. |
+## Self-correct mode (dual-mode invocation)
+
+```
+/wbValid <scope_folder>           # normal mode — produce a fresh output file
+/wbValid <previous_output_file>   # self-correct mode — verify & repair the file in place
+```
+
+When the first arg is an existing output file from a prior `/wbValid` run (detected by its first H1 — see this template's **Detection** section), the command runs in **verify-and-repair** mode: gap-fills missing fields, normalizes links, ticks done/valid checkboxes whose reports exist, never rewrites authored content. See [`../_shared/output_conventions.md`](../_shared/output_conventions.md) §3.
+
+<!-- FLAGS_TABLE_END -->
+<!-- HELP_GATE_END -->
+
+<!-- FLAG_NORMALIZE_START -->
+## Flag normalization (apply BEFORE parsing args)
+- `-i` → `--id`
+- `-o` → `--open`
+- `-d` → `--def`
+- `-c` → `--can`
+<!-- FLAG_NORMALIZE_END -->
+
+**ROLE:** The Validator / QA
+**TARGET:** The provided plan file (absolute path, relative path, or just the filename).
+**Read first:** [`../_shared/output_conventions.md`](../_shared/output_conventions.md)
+
+## ━━━ OBJECTIVE ━━━
+Your job is to locate the specified plan or idea file, parse its table, determine the operating workspace, and physically validate the tasks/ideas requested by the user's flags.
+
+## ━━━ MODE DETECTION ━━━
+
+Read the target file's first H1 header to determine the operating mode:
+
+- **`# Plan Backlog: <scope> — <date>`** → **PLAN MODE** (standard behavior, documented below).
+- **`# Idea Backlog: <scope> — <date>`** → **IDEAS MODE** (see §IDEAS below).
+
+## ━━━ INSTRUCTIONS (PLAN MODE) ━━━
+
+1. **Locate the Plan:** Read the target file. If only a filename is provided (e.g. `plan_core2_20260503.md`), infer the workspace and locate it at `<pkg>/.wb/workflows/reports/<YYYY>/<MM>/<DD>/plans/<filename>`.
+2. **Parse Intent:**
+   - If no flag is given (e.g., `/wbValid plan_file.md`): This is **Self-Correction / Re-check Mode**. Do NOT just output state. Actively scan the plan file and the related task reports for missing data or formatting errors (e.g., missing scores out of 10, broken links, missing fields). Fix them immediately. Task reports are located at `tasks/task_<N>/task_<N>_report_<scope>_<YYYYMMDD>.md`.
+   - If a target filter is provided WITH a state flag (`--open`, `--def`, `--can`): Do NOT execute validation. Instead, directly edit the plan file and update the `☐ Valid` column of the matching tasks to the requested state.
+   - If a target filter is provided WITHOUT state flags (e.g., `--id=2` or `--done=true`): Proceed to validate those specific tasks matching the criteria.
+3. **Validation Logic (if executing):**
+   - Universal Column Filtering: You must apply the filter logic to any column of the table (e.g., `#`, `P`, `Est. Time (mins)`, `Worker`, `☐ Done`, `☐ Valid`).
+   - Recursive Task Logic: If the filter matches a parent recursive task (e.g., `--id=5`), this implies validating ALL of its child tasks (e.g., 5.1, 5.2, 5.3, 5.4) sequentially with your current model.
+   - Read the corresponding `tasks/task_<ID>/task_<ID>_report_*.md` report.
+   - Inspect the workspace to confirm the work was done to high standards.
+   - Append a `## 🔍 Validation (QA)` section to the bottom of the Worker's task report.
+   - You MUST include a **Score / 10** evaluating the Worker's quality, efficiency, and adherence to constraints.
+   - State clearly if it is a PASS ✅ or FAIL ❌.
+4. **Update Plan:** 
+   - **Cumulative Validation Rule:** The `☐ Valid` column accumulates validations (unlike the `☐ Done` column). 
+   - If PASS and the column is `⬜` (empty), update it to `✅ 10/10<br><ModelName>`.
+   - If PASS and the column already has a validation (e.g., `✅ 10/10<br>DeepSeek`), **APPEND** your validation below it: `...<hr>✅ <Score>/10<br><ModelName>`.
+   - If FAIL, revert the `☐ Done` column back to `⬜` so the worker can try again.
+
+## ━━━ §IDEAS: INSTRUCTIONS (IDEAS MODE) ━━━
+
+When the target file is an `idea_*.md` file (H1 = `# Idea Backlog:`):
+
+1. **Locate the Idea File:** Same pathing logic as plan files, but routed to `ideas/idea_<scope>_<YYYYMMDD>.md`.
+2. **Parse Intent:**
+   - If no flag is given → **Self-Correction / Re-check Mode** on the idea file.
+   - If a target filter WITH a state flag (`--open`, `--defer`, `--reject`, `--promote`) → Update the `☐ Valid` column directly.
+   - If a target filter WITHOUT state flags → Proceed to **Idea Validation Mode**.
+3. **Idea Validation Mode:**
+   - Read the idea exploration report (if it exists) at `ideas_reports/idea_<ID>/idea_<ID>_report_*.md`.
+   - Read the idea description from the `Idea` column.
+   - Analyze the idea against the codebase context, existing plans, and current priorities.
+   - Append a `## 🔍 Idea Validation (QA)` section to the bottom of the idea exploration report (if it exists; otherwise append to the idea file itself as a note).
+   - You MUST include a **Score / 10** and a **Verdict** from the verdict scale below.
+
+4. **Idea Verdict Scale:**
+
+   | Verdict | Score Range | ☐ Valid State | Meaning | Auto-Action |
+   |---|---|---|---|---|
+   | `🎯 Promote` | 8–10 | `🎯 Promoted <Score>/10<br>ModelName` | "This deserves to become a task" | **Triggers Promotion Protocol** (see wbIdea_template.md) |
+   | `✅ Recommend` | 5–7 | `✅ <Score>/10<br>ModelName` | "Good idea, worth doing when capacity allows" | No auto-promotion |
+   | `⏸️ Defer` | 3–4 | `⏸️ Deferred <Score>/10<br>ModelName` | "Interesting but not the right time" | No action |
+   | `🚫 Reject` | 1–2 | `🚫 Rejected <Score>/10<br>ModelName` | "Not worth pursuing" | No action |
+
+   The validation report MUST explain the verdict with concrete reasoning:
+   - For `🎯 Promote`: "It deserves to be moved to a plan with score X because..."
+   - For `✅ Recommend`: "I recommend it with score X because..."
+   - For `⏸️ Defer`: "Defer because..."
+   - For `🚫 Reject`: "Don't do it since..."
+
+5. **Update Idea File:**
+   - **Cumulative:** Same as plan validation. Append new validations below existing ones.
+   - If verdict is `🎯 Promote`, **also execute the Promotion Protocol**:
+     a. Locate (or create) today's plan file.
+     b. Append the idea as a new task row (see wbIdea_template.md §PROMOTION PROTOCOL for column mapping).
+     c. Update the idea file's `→ Task` column with the plan link.
+   - Validation report is appended to the idea report (same pattern as task validation appended to task reports).
+
+## 🧭 What's Next?
+- **Plan Mode:** If the plan is fully validated, tell the user to run `/wbReview <target>` for a final overarching audit, or `/wbStandup <target>` to close out the session.
+- **Ideas Mode:** If ideas are validated:
+  - Promoted ideas → tell the user to run `/wbWork plan_<scope>_<YYYYMMDD>.md --id=<N>` to execute the promoted task.
+  - Recommended ideas → suggest revisiting with `/wbIdea <target> --resume` when capacity allows.
+  - Tell the user to run `/wbPlan <target> --resume` to see promoted ideas integrated into the plan.

package/templates/commands/wbVision/wbVision_template.md

@@ -0,0 +1,141 @@
+# /wbVision: Execution Template
+
+
+<!-- HELP_GATE_START -->
+## Help intercept (handle FIRST — before any other action)
+
+**If `$ARGUMENTS` contains `--help`, `-h`, or `--h`** (case-insensitive, anywhere in the args), DO NOT execute the command's normal procedure. Instead:
+
+1. Output the **HELP BLOCK** below verbatim (rendered as markdown).
+2. Stop. Do not perform any file reads, writes, or other tool calls.
+3. Do not generate any reports under `.wb/workflows/reports/`.
+
+Otherwise, ignore this section and proceed to the rest of the template.
+
+### HELP BLOCK — `/wbVision`
+
+## Two forms
+
+```
+/wbVision <package>            # package-specific feature ideas
+/wbVision core2/               # cross-package / monorepo-wide ideas
+```
+
+The cross-package form is generally more useful than the per-package form.
+
+## When to run
+
+- Occasionally (monthly or less). Daily use flattens your own judgment.
+- After a major release cycle closed, when queue is genuinely empty.
+- Before `/wbSetup` on a new package — ask what this package *should* contain.
+
+## When *not* to run
+
+- Daily. Brainstorming on a clock dulls intuition.
+- As a substitute for `/wbStandup` ("what should I do today?"). Standup reconciles existing work; vision invents new work. Different questions.
+- When you already have a plan. The plan is the answer; don't re-brainstorm.
+
+## Reading the output
+
+Each idea should have:
+
+- **Premise** — one-sentence description.
+- **Value** — why it matters.
+- **Risk** — what could go wrong.
+- **Effort** — SMALL / MEDIUM / LARGE.
+
+If any field is missing, the idea is underspecified. Push back: *"re-run but put all 4 fields on every idea."*
+
+## The filtering step is the command's actual value
+
+You read 6 ideas. You discard 4 as obvious or generic. You discard 1 more as "interesting but wrong timing." The 1 that remains is the vision output. If all 6 survive, you haven't filtered hard enough.
+
+## The anti-pattern
+
+**Running `/wbVision` on a package that has open work.** If `/wbStandup` shows open plans and unresolved findings, the "what next?" question has an answer already. Vision is for when the answer is genuinely empty.
+
+## The most useful invocation
+
+Cross-package (`/wbVision core2/`) with a focus on integration ideas — things that couldn't be seen at package scope. This is where `/wbVision` earns its place over "just brainstorm with an AI."
+
+## When /wbVision is the wrong command
+
+- Reconcile state → `/wbStandup`.
+- Execute on committed work → `/wbPlan`.
+- Fix a bug → `/wbDebug`.
+- Business / market / user research → `/wbVision` can't see these; do it yourself.
+
+> For deeper reading: [`docs_claude/commands/wbVision/wbVision_practical_claude.md`](../../docs/docs_claude/commands/wbVision/wbVision_practical_claude.md) (or the `_eli5_`, `_expert_`, `_examples_` siblings).
+## Self-correct mode (dual-mode invocation)
+
+```
+/wbVision <scope_folder>           # normal mode — produce a fresh output file
+/wbVision <previous_output_file>   # self-correct mode — verify & repair the file in place
+```
+
+When the first arg is an existing output file from a prior `/wbVision` run (detected by its first H1 — see this template's **Detection** section), the command runs in **verify-and-repair** mode: gap-fills missing fields, normalizes links, ticks done/valid checkboxes whose reports exist, never rewrites authored content. See [`../_shared/output_conventions.md`](../_shared/output_conventions.md) §3.
+
+<!-- HELP_GATE_END -->
+
+**ROLE:** The Strategist
+**TARGET:** The provided component, package, or monorepo root.
+**Read first:** [`../_shared/output_conventions.md`](../_shared/output_conventions.md) — applies to the proposal file (relative links, full-syntax commands, self-correct mode, **§9 Action Type Tagging** — declare `type:` + `emits:` in YAML front-matter, add a plain-text `Requires` column to every suggestion table, include a `## 🔗 Action Types` legend).
+
+---
+
+## ━━━ DETECTION (Self-Correct Mode) ━━━
+
+Trigger self-correct when the input file's first H1 matches:
+`# Vision: <scope> — <YYYY-MM-DD>` *(or the legacy `# Vision Entry #N` header).*
+
+Behavior is defined in [`../_shared/output_conventions.md`](../_shared/output_conventions.md) §3.
+
+Vision-specific gap-fills:
+
+- Plain-text references to existing components/packages → relative markdown links per §1.
+- Bare `/wbPlan` reference at the bottom → full-syntax `/wbPlan <target> "<idea>"` per §2.
+
+---
+
+## ━━━ OBJECTIVE ━━━
+The project has a blank slate. There is no tech debt and no pending tasks. Your job is to analyze what the project currently is, and propose 3 highly innovative, strategic features to build next to increase its value.
+
+## ━━━ PHASE 1: INGEST IDENTITY ━━━
+1. Read the local `context.md` to understand what this package does.
+2. Read the global `ecosystem_urls.md` to understand where this package fits in the broader market.
+
+## ━━━ PHASE 2: STRATEGIC BRAINSTORMING ━━━
+Do not suggest bug fixes or minor refactors. Propose major architectural leaps, premium features, or integrations that would "Wow" the users.
+
+## ━━━ PHASE 3: THE PROPOSAL ━━━
+Generate a proposal file:
+- **Path:** `.wb/workflows/reports/<YYYY>/<MM>/<DD>/visions/vision_<target>_<YYYYMMDD>.md`
+- **No `<model>/` subfolder.** Create-or-append: if the file exists, append your vision as the next Entry #N tagged `*(ModelName — HH:MM)*`.
+- **Format:** Present 3 distinct feature ideas. For each, explain *Why it matters* and *How complex it would be*. Apply output_conventions.md §1 (relative links for every existing-component reference) and §2 (full-syntax for any /wb* command cited).
+- **Next Steps:** End the file with a `## 🧭 What's Next?` section: *"If you like one of these ideas, run `/wbPlan <target> "<idea>"` to begin execution. Run `/wbNext <target>` to see how it ranks against current debt."*
+
+## ━━━ PHASE 4: AUTO-REGISTER IDEAS ━━━
+
+After writing the vision proposal, you MUST ALSO register each idea in the Ideas Pipeline:
+
+1. **Locate or create** today's idea file: `<target>/.wb/workflows/reports/<YYYY>/<MM>/<DD>/ideas/idea_<target>_<YYYYMMDD>.md`
+2. **For each idea** in the vision proposal:
+   - Compute a **Score** (1–10) using the scoring heuristic from `wbIdea_template.md` (impact × feasibility × urgency).
+   - Append a row to the idea table:
+     - `Score` = computed score
+     - `Idea` = the idea's Premise (one-line)
+     - `P` = inferred priority (P1 for SMALL/MEDIUM, P2 for LARGE)
+     - `Est. Time` = inferred from Effort (SMALL=30, MEDIUM=120, LARGE=480)
+     - `Suggested By` = `<ModelName> via /wbVision`
+     - `☐ Done` = `⬜`
+     - `☐ Valid` = `⬜`
+     - `→ Task` = `—`
+3. **Add an entry header** in the idea file:
+   ```
+   ## 💡 Ideas — /wbVision proposals *(<ModelName> via <Client> — <HH:MM>)*
+   > **Source:** [vision_<target>_<YYYYMMDD>.md](../visions/vision_<target>_<YYYYMMDD>.md)
+   > **Origin Command:** `/wbVision <target>/`
+   > **Ideas registered:** N
+   ```
+4. **Both files coexist**: The vision file remains the free-form brainstorming artifact. The idea file is the trackable, actionable pipeline. The vision file is the source; the idea file is the tracker.
+

package/templates/commands/wbWork/wbWork_template.md

@@ -0,0 +1,140 @@
+# /wbWork: Execution Template
+
+<!-- HELP_GATE_START -->
+## Help intercept (handle FIRST — before any other action)
+
+**If `$ARGUMENTS` contains `--help`, `-h`, or `--h`** (case-insensitive, anywhere in the args), DO NOT execute the command's normal procedure. Instead:
+
+1. Output the **HELP BLOCK** below verbatim (rendered as markdown).
+2. Stop. Do not perform any file reads, writes, or other tool calls.
+
+### HELP BLOCK — `/wbWork`
+
+## The Command Forms
+
+```
+/wbWork <path_to_plan.md>               # State what work is needed
+/wbWork <path_to_plan.md> *             # Execute all tasks that need work
+/wbWork <path_to_plan.md> --id=1,2,3    # Execute specifically tasks 1, 2, and 3
+/wbWork <path_to_plan.md> --p=P1          # Execute all tasks with P1 priority
+/wbWork <path_to_plan.md> --est<=30       # Execute tasks with est. time <= 30 mins
+/wbWork <path_to_plan.md> --valid=true    # Execute tasks that are already validated (re-work)
+/wbWork <path_to_plan.md> --done=false    # Execute all open tasks
+/wbWork <path_to_plan.md> --id=5 --open   # Set task 5 Done column to ⬜
+/wbWork <path_to_plan.md> --worker=Gemini # Execute tasks assigned to Gemini
+/wbWork <scope_folder> "<issue desc>"     # Inline Task: Auto-triage, add to today's plan, and execute
+```
+
+**Shorthand Pathing:** You can pass just the filename (e.g., `plan_core2_20260503.md`). The AI will infer the package (`core2`) and the date (`2026/05/03`) to construct the full path: `<pkg>/.wb/workflows/reports/<YYYY>/<MM>/<DD>/plans/<filename>`.
+
+## When to run
+- When you have an active `/wbPlan` and you are acting as the **Worker** model.
+- Use it to mechanically execute steps directly from the plan table.
+
+## The Output
+`/wbWork` doesn't just execute code—it generates a formal task report (`tasks/task_<N>/task_<N>_report_<scope>_<YYYYMMDD>.md`) detailing what was done, and updates the `☐ Done` column to `✅` in the parent plan file.
+
+<!-- FLAGS_TABLE_START -->
+## Flags & shortcuts
+
+| `--id`, `--p`, `--est`, etc. | `-i`, etc. | Universal Column Filtering. Targets tasks based on any column in the plan table (supports `=, >, <, !=, *, &&, ||`). |
+| `--open` | `-o` | Sets `☐ Done` state to `⬜` (Open). Overrides execution. |
+| `--def` | `-d` | Sets `☐ Done` state to `⏸️ Deferred`. Overrides execution. |
+| `--can` | `-c` | Sets `☐ Done` state to `🚫 Cancelled`. Overrides execution. |
+| `--help` | `-h` | Prints this help block. |
+## Self-correct mode (dual-mode invocation)
+
+```
+/wbWork <scope_folder>           # normal mode — produce a fresh output file
+/wbWork <previous_output_file>   # self-correct mode — verify & repair the file in place
+```
+
+When the first arg is an existing output file from a prior `/wbWork` run (detected by its first H1 — see this template's **Detection** section), the command runs in **verify-and-repair** mode: gap-fills missing fields, normalizes links, ticks done/valid checkboxes whose reports exist, never rewrites authored content. See [`../_shared/output_conventions.md`](../_shared/output_conventions.md) §3.
+
+<!-- FLAGS_TABLE_END -->
+<!-- HELP_GATE_END -->
+
+<!-- FLAG_NORMALIZE_START -->
+## Flag normalization (apply BEFORE parsing args)
+- `-i` → `--id`
+- `-o` → `--open`
+- `-d` → `--def`
+- `-c` → `--can`
+<!-- FLAG_NORMALIZE_END -->
+
+**ROLE:** The Worker / Executor
+**TARGET:** The provided plan file (absolute path, relative path, or just the filename).
+**Read first:** [`../_shared/output_conventions.md`](../_shared/output_conventions.md)
+
+## ━━━ OBJECTIVE ━━━
+Your job is to locate the specified plan or idea file, parse its table, determine the operating workspace, and physically execute the tasks/ideas requested by the user's flags.
+
+## ━━━ MODE DETECTION ━━━
+
+Read the target file's first H1 header to determine the operating mode:
+
+- **`# Plan Backlog: <scope> — <date>`** → **PLAN MODE** (standard behavior, documented below).
+- **`# Idea Backlog: <scope> — <date>`** → **IDEAS MODE** (see §IDEAS below).
+- **Inline task with `idea:` prefix** (e.g., `/wbWork <scope> "idea: add CSV export"`) → **IDEA REGISTRATION MODE** (routes to idea file instead of plan file).
+
+## ━━━ INSTRUCTIONS (PLAN MODE) ━━━
+
+1. **Locate the Plan:** Read the target file. If only a filename is provided (e.g. `plan_core2_20260503.md`), infer the workspace and locate it at `<pkg>/.wb/workflows/reports/<YYYY>/<MM>/<DD>/plans/<filename>`. If an inline task is provided (`/wbWork <scope_folder> "<issue>"`), find or create today's plan file for that scope.
+2. **Pre-Flight Triage (Inline Tasks):** If an issue description is provided instead of an ID:
+   - **`idea:` prefix detection:** If the description starts with `idea:` or `💡`, route to **IDEA REGISTRATION MODE** (see below) instead of the plan file.
+   - **Assess Complexity:** Assign a priority (P0-P3).
+   - **Simple (P2/P3):** Append a row to the plan's task table (Origin: "Manual", Task: "<desc>"). Proceed to Execution Mode.
+   - **Complex (P0/P1):** Append a parent row. Spawn a `/wbPlan` sub-process logically to break it into sub-tasks (e.g., `#N.1`, `#N.2`). Append the sub-plan table. Proceed to sequentially execute the sub-tasks.
+3. **Parse Intent:**
+   - If no flag is given (e.g., `/wbWork plan_file.md`): This is **Self-Correction / Re-check Mode**. Do NOT just output state. Actively scan the plan file and the related task reports for missing data or formatting errors. Fix them immediately.
+   - If a target filter is provided WITH a state flag (`--open`, `--def`, `--can`): Do NOT execute the task. Instead, directly edit the plan file and update the `☐ Done` column of the matching tasks to the requested state.
+   - If a target filter is provided WITHOUT state flags (e.g., `--id=2` or `--p=P1`): Proceed to execute those specific tasks matching the criteria.
+3. **Execution Mode:**
+   - Universal Column Filtering: You must apply the filter logic to any column of the table (e.g., `#`, `P`, `Est. Time (mins)`, `Worker`, `☐ Done`, `☐ Valid`).
+   - Recursive Task Logic: If the filter matches a parent recursive task (e.g., `--id=5`), this implies executing ALL of its child tasks (e.g., 5.1, 5.2, 5.3, 5.4) sequentially with your current model.
+   - Follow the `Task` description in the plan exactly.
+   - Perform the file edits, script executions, or tool calls needed.
+4. **Report Generation:**
+   - For EACH task executed, create a report at: `.wb/workflows/reports/<YYYY>/<MM>/<DD>/plans/tasks/task_<ID>/task_<ID>_report_<TARGET>_<YYYYMMDD>.md`
+   - Create the `task_<ID>/` folder if it does not exist.
+   - Use the standard `# Task <ID>: <Title>` header format.
+5. **Plan Update:**
+   - Edit the original plan file. Change the `#` column to a markdown link pointing to your new task report (e.g., `[<ID>](tasks/task_<ID>/task_<ID>_report_<TARGET>_<YYYYMMDD>.md)`).
+   - Change `☐ Done` to `✅<br>__YOUR_MODEL_NAME__`. **OVERWRITE rule:** The Done column is NOT cumulative. If another model's name is already there, completely overwrite it with yours. Only the final executor is tracked.
+
+## ━━━ §IDEAS: INSTRUCTIONS (IDEAS MODE) ━━━
+
+When the target file is an `idea_*.md` file (H1 = `# Idea Backlog:`):
+
+1. **Locate the Idea File:** Same pathing logic as plan files, but routed to `ideas/idea_<scope>_<YYYYMMDD>.md`.
+2. **Parse Intent:**
+   - If no flag is given → **Self-Correction / Re-check Mode** on the idea file.
+   - If a target filter is provided WITH a state flag (`--open`, `--def`, `--can`) → Update the `☐ Done` column of matching ideas.
+   - If a target filter is provided WITHOUT state flags → Proceed to **Idea Exploration Mode**.
+3. **Idea Exploration Mode:**
+   - Read the idea description from the `Idea` column.
+   - **Explore the idea in depth**: feasibility analysis, impact assessment, implementation sketch, risks, estimated cost if promoted.
+   - Do NOT implement the idea. Only analyze and document.
+4. **Report Generation (Ideas):**
+   - For EACH idea explored, create a report at: `.wb/workflows/reports/<YYYY>/<MM>/<DD>/ideas/ideas_reports/idea_<ID>/idea_<ID>_report_<TARGET>_<YYYYMMDD>.md`
+   - Create the `idea_<ID>/` folder if it does not exist.
+   - Use the header format: `# Idea <ID>: <Title> — Exploration Report`
+   - Include: High-Level Summary, Feasibility Analysis, Impact Assessment, Implementation Sketch, Risks & Mitigations, Estimated Cost if Promoted, Recommendation (promote / defer / reject with reasoning).
+5. **Idea File Update:**
+   - Change the `#` column to a link: `[<ID>](ideas_reports/idea_<ID>/idea_<ID>_report_<TARGET>_<YYYYMMDD>.md)`.
+   - Change `☐ Done` to `✅<br>__YOUR_MODEL_NAME__`.
+
+## ━━━ §IDEA_REG: IDEA REGISTRATION MODE ━━━
+
+When an inline description starts with `idea:` or `💡` (e.g., `/wbWork <scope> "idea: add CSV export"`):
+
+1. Strip the `idea:` or `💡` prefix to get the idea description.
+2. Locate (or create) today's idea file: `<scope>/.wb/workflows/reports/<YYYY>/<MM>/<DD>/ideas/idea_<scope>_<YYYYMMDD>.md`.
+3. Compute a Score (1–10) using the scoring heuristic from `wbIdea_template.md`.
+4. Append a new row to the idea table with: Score, Idea description, Priority, Est. Time, `Suggested By: Manual`, `☐ Done: ⬜`, `☐ Valid: ⬜`, `→ Task: —`.
+5. Do NOT execute the idea. Output: "Idea registered as #N in idea_<scope>_<YYYYMMDD>.md."
+
+## 🧭 What's Next?
+- **Plan Mode:** End your response by telling the user to run `/wbValid <target> --id=<ID>` to formally validate the work you just completed.
+- **Ideas Mode:** End your response by telling the user to run `/wbValid idea_<scope>_<YYYYMMDD>.md --id=<ID>` to validate the exploration and potentially promote the idea to a plan.
+- **Idea Registration Mode:** End your response by suggesting `/wbWork idea_<scope>_<YYYYMMDD>.md --id=<N>` to explore the newly registered idea.