@leeovery/claude-technical-workflows 2.1.23 → 2.1.25

package/skills/status/SKILL.md

@@ -27,32 +27,37 @@ docs/workflow/research/
 docs/workflow/discussion/
 docs/workflow/specification/
 docs/workflow/planning/
+docs/workflow/implementation/
 ```
 
+For implementation, check `docs/workflow/implementation/{topic}/tracking.md` files and extract frontmatter fields: `status`, `current_phase`, `current_task`, `completed_tasks`, `completed_phases`.
+
 ## Step 2: Present Status
 
 Research is project-wide exploration. From discussion onwards, work is organised by **topic** - different topics may be at different stages.
 
-Show a summary like this:
+> *Output the next fenced block as markdown (not a code block):*
 
 ```
-## Workflow Status
-
-**Research:** 2 files (exploration.md, market-analysis.md)
+**Workflow Overview**
 
-**Topics:**
+**Research:** {count} files ({filenames})
 
-| Topic        | Discussion | Spec | Plan | Implemented |
-|--------------|------------|------|------|-------------|
-| auth-system  | ✓          | ✓    | ✓    | in progress |
-| payment-flow | ✓          | ✓    | -    | -           |
-| notifications| ✓          | -    | -    | -           |
+| Topic | Discussion | Spec | Plan | Implemented |
+|-------|------------|------|------|-------------|
+| {topic} | {discussion_status} | {spec_status} | {plan_status} | {impl_status} |
+| ... | | | | |
 ```
 
 Adapt based on what exists:
-- If a directory is empty or missing, show "Not started"
+- If a directory is empty or missing, show `-`
 - For planning, note the output format if specified in frontmatter
 - Match topics across phases by filename
+- For implementation, derive the Implemented column from tracking file data:
+  - No tracking file → `-`
+  - `status: not-started` → `not started`
+  - `status: in-progress` → `phase {current_phase} ({n}/{total} tasks done)` — count `completed_tasks` for n; use total task count from `completed_tasks` + remaining if available, otherwise just show completed count
+  - `status: completed` → `completed`
 
 ## Step 3: Suggest Next Steps
 
@@ -75,6 +80,8 @@ Keep suggestions brief - the user knows their project's dependencies better than
 
 If planning files exist, let the user know they can view plan details:
 
+> *Output the next fenced block as a code block:*
+
 ```
 To view a plan's tasks and progress, use /view-plan
 ```

package/skills/technical-implementation/SKILL.md

@@ -31,13 +31,13 @@ Either way: dispatch agents per task — executor implements via TDD, reviewer v
 **Before proceeding**, verify all required inputs are available and unambiguous. If anything is missing or unclear, **STOP** — do not proceed until resolved.
 
 - **No plan provided?**
-  > "I need an implementation plan to execute. Could you point me to the plan file (e.g., `docs/workflow/planning/{topic}.md`)?"
+  "I need an implementation plan to execute. Could you point me to the plan file (e.g., `docs/workflow/planning/{topic}.md`)?"
 
 - **Plan has no `format` field in frontmatter?**
-  > "The plan at {path} doesn't specify an output format in its frontmatter. Which format does this plan use?"
+  "The plan at {path} doesn't specify an output format in its frontmatter. Which format does this plan use?"
 
 - **Plan status is not `concluded`?**
-  > "The plan at {path} has status '{status}' — it hasn't completed the review process. Should I proceed anyway, or should the plan be reviewed first?"
+  "The plan at {path} has status '{status}' — it hasn't completed the review process. Should I proceed anyway, or should the plan be reviewed first?"
 
 If no specification is available, the plan becomes the sole authority for design decisions.
 
@@ -91,7 +91,7 @@ Follow them. Complete ALL steps before proceeding.
 
 Ask:
 
-> "No environment setup document found. Are there any setup instructions I should follow before implementing?"
+"No environment setup document found. Are there any setup instructions I should follow before implementing?"
 
 **STOP.** Wait for user response.
 
@@ -166,16 +166,18 @@ Commit: `impl({topic}): start implementation`
 
 Present the existing configuration for confirmation:
 
-> Previous session used these project skills:
-> - `{skill-name}` — {path}
-> - ...
->
-> · · · · · · · · · · · ·
-> - **`y`/`yes`** — Keep these, proceed
-> - **`c`/`change`** — Re-discover and choose skills
-> · · · · · · · · · · · ·
+> *Output the next fenced block as markdown (not a code block):*
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+```
+Previous session used these project skills:
+- `{skill-name}` — {path}
+- ...
+
+· · · · · · · · · · · ·
+- **`y`/`yes`** — Keep these, proceed
+- **`c`/`change`** — Re-discover and choose skills
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user choice.
 
@@ -184,6 +186,8 @@ Present the existing configuration for confirmation:
 
 #### If `.claude/skills/` does not exist or is empty
 
+> *Output the next fenced block as a code block:*
+
 ```
 No project skills found. Proceeding without project-specific conventions.
 ```
@@ -194,18 +198,20 @@ No project skills found. Proceeding without project-specific conventions.
 
 Scan `.claude/skills/` for project-specific skill directories. Present findings:
 
-> Found these project skills that may be relevant to implementation:
-> - `{skill-name}` — {brief description}
-> - `{skill-name}` — {brief description}
-> - ...
->
-> · · · · · · · · · · · ·
-> - **`a`/`all`** — Use all listed skills
-> - **`n`/`none`** — Skip project skills
-> - **Or list the ones you want** — e.g. "golang-pro, react-patterns"
-> · · · · · · · · · · · ·
+> *Output the next fenced block as markdown (not a code block):*
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+```
+Found these project skills that may be relevant to implementation:
+- `{skill-name}` — {brief description}
+- `{skill-name}` — {brief description}
+- ...
+
+· · · · · · · · · · · ·
+- **`a`/`all`** — Use all listed skills
+- **`n`/`none`** — Skip project skills
+- **Or list the ones you want** — e.g. "golang-pro, react-patterns"
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user to confirm which skills are relevant.
 
@@ -223,19 +229,21 @@ If `linters` is already populated in the tracking file, present the existing con
 
 Otherwise, present discovery findings to the user:
 
-> **Linter discovery:**
-> - {tool} — `{command}` (installed / not installed)
-> - ...
->
-> Recommendations: {any suggested tools with install commands}
->
-> · · · · · · · · · · · ·
-> - **`y`/`yes`** — Approve these linter commands
-> - **`c`/`change`** — Modify the linter list
-> - **`s`/`skip`** — Skip linter setup (no linting during TDD)
-> · · · · · · · · · · · ·
-
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+**Linter discovery:**
+- {tool} — `{command}` (installed / not installed)
+- ...
+
+Recommendations: {any suggested tools with install commands}
+
+· · · · · · · · · · · ·
+- **`y`/`yes`** — Approve these linter commands
+- **`c`/`change`** — Modify the linter list
+- **`s`/`skip`** — Skip linter setup (no linting during TDD)
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user choice.
 

package/skills/technical-implementation/references/steps/analysis-loop.md

@@ -28,16 +28,18 @@ If `analysis_cycle > 3`:
 
 **Do NOT skip analysis autonomously.** This gate is an escape hatch for the user — not a signal to stop. The expected default is to continue running analysis until no issues are found. Present the choice and let the user decide.
 
-> **Analysis cycle {N}**
->
-> Analysis has run {N-1} times so far. You can continue (recommended if issues were still found last cycle) or skip to completion.
->
-> · · · · · · · · · · · ·
-> - **`p`/`proceed`** — Continue analysis *(default)*
-> - **`s`/`skip`** — Skip analysis, proceed to completion
-> · · · · · · · · · · · ·
+**Analysis cycle {N}**
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+Analysis has run {N-1} times so far. You can continue (recommended if issues were still found last cycle) or skip to completion.
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+- **`p`/`proceed`** — Continue analysis *(default)*
+- **`s`/`skip`** — Skip analysis, proceed to completion
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user choice. You MUST NOT choose on the user's behalf.
 
@@ -57,17 +59,19 @@ If there are unstaged changes or untracked files, categorize them:
 - **Implementation files** (files touched by `impl({topic}):` commits) — stage these automatically.
 - **Unexpected files** (files not touched during implementation) — present to the user:
 
-> **Pre-analysis checkpoint — unexpected files detected:**
-> - `{file}` ({status: modified/untracked})
-> - ...
->
-> · · · · · · · · · · · ·
-> - **`y`/`yes`** — Include all in the checkpoint commit
-> - **`s`/`skip`** — Exclude unexpected files, commit only implementation files
-> - **Comment** — Specify which to include
-> · · · · · · · · · · · ·
+**Pre-analysis checkpoint — unexpected files detected:**
+- `{file}` ({status: modified/untracked})
+- ...
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+- **`y`/`yes`** — Include all in the checkpoint commit
+- **`s`/`skip`** — Exclude unexpected files, commit only implementation files
+- **Comment** — Specify which to include
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user choice.
 
@@ -121,37 +125,39 @@ Read the staging file from `docs/workflow/implementation/{topic}/analysis-tasks-
 
 Present an overview:
 
-> **Analysis cycle {N}: {K} proposed tasks**
->
-> 1. {title} ({severity})
-> 2. {title} ({severity})
-> ...
+**Analysis cycle {N}: {K} proposed tasks**
+
+1. {title} ({severity})
+2. {title} ({severity})
+...
 
 Then present each task with `status: pending` individually:
 
-> **Task {current}/{total}: {title}** ({severity})
-> Sources: {sources}
->
-> **Problem**: {problem}
-> **Solution**: {solution}
-> **Outcome**: {outcome}
->
-> **Do**:
-> {steps}
->
-> **Acceptance Criteria**:
-> {criteria}
->
-> **Tests**:
-> {tests}
->
-> · · · · · · · · · · · ·
-> - **`a`/`approve`** — Approve this task
-> - **`s`/`skip`** — Skip this task
-> - **Comment** — Revise based on feedback
-> · · · · · · · · · · · ·
-
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+**Task {current}/{total}: {title}** ({severity})
+Sources: {sources}
+
+**Problem**: {problem}
+**Solution**: {solution}
+**Outcome**: {outcome}
+
+**Do**:
+{steps}
+
+**Acceptance Criteria**:
+{criteria}
+
+**Tests**:
+{tests}
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+- **`a`/`approve`** — Approve this task
+- **`s`/`skip`** — Skip this task
+- **Comment** — Revise based on feedback
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user input.
 

package/skills/technical-implementation/references/steps/task-loop.md

@@ -40,17 +40,19 @@ E. Update progress + commit
 
 Present the executor's ISSUES to the user:
 
-> **Task {id}: {Task Name} — {blocked/failed}**
->
-> {executor's ISSUES content}
->
-> · · · · · · · · · · · ·
-> - **`r`/`retry`** — Re-invoke the executor with your comments (provide below)
-> - **`s`/`skip`** — Skip this task and move to the next
-> - **`t`/`stop`** — Stop implementation entirely
-> · · · · · · · · · · · ·
-
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+**Task {id}: {Task Name} — {blocked/failed}**
+
+{executor's ISSUES content}
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+- **`r`/`retry`** — Re-invoke the executor with your comments (provide below)
+- **`s`/`skip`** — Skip this task and move to the next
+- **`t`/`stop`** — Stop implementation entirely
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user choice.
 
@@ -84,7 +86,7 @@ Increment `fix_attempts` in the implementation tracking file.
 
 Announce the fix round (one line, no stop):
 
-> **Review for Task {id}: {Task Name} — needs changes** (attempt {N}/{max 3}, fix analysis included). Re-invoking executor.
+**Review for Task {id}: {Task Name} — needs changes** (attempt {N}/{max 3}, fix analysis included). Re-invoking executor.
 
 → Return to the top of **B. Execute Task** and re-invoke the executor with the full task content and the reviewer's notes (including fix analysis).
 
@@ -92,25 +94,27 @@ Announce the fix round (one line, no stop):
 
 If `fix_attempts >= 3`, the executor and reviewer have failed to converge. Prepend:
 
-> The executor and reviewer have not converged after {N} attempts. Escalating for human review.
+The executor and reviewer have not converged after {N} attempts. Escalating for human review.
 
 Present the reviewer's findings and fix analysis to the user:
 
-> **Review for Task {id}: {Task Name} — needs changes** (attempt {N})
->
-> {ISSUES from reviewer, including FIX, ALTERNATIVE, and CONFIDENCE for each}
->
-> Notes (non-blocking):
-> {NOTES from reviewer}
->
-> · · · · · · · · · · · ·
-> - **`y`/`yes`** — Accept the review and fix analysis, pass to executor
-> - **`a`/`auto`** — Accept and auto-approve future fix analyses
-> - **`s`/`skip`** — Override the reviewer and proceed as-is
-> - **Comment** — Any commentary, adjustments, alternative approaches, or questions before passing to executor
-> · · · · · · · · · · · ·
-
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+**Review for Task {id}: {Task Name} — needs changes** (attempt {N})
+
+{ISSUES from reviewer, including FIX, ALTERNATIVE, and CONFIDENCE for each}
+
+Notes (non-blocking):
+{NOTES from reviewer}
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+- **`y`/`yes`** — Accept the review and fix analysis, pass to executor
+- **`a`/`auto`** — Accept and auto-approve future fix analyses
+- **`s`/`skip`** — Override the reviewer and proceed as-is
+- **Comment** — Any commentary, adjustments, alternative approaches, or questions before passing to executor
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user choice.
 
@@ -129,19 +133,21 @@ After the reviewer approves a task, check the `task_gate_mode` field in the impl
 
 Present a summary and wait for user input:
 
-> **Task {id}: {Task Name} — approved**
->
-> Phase: {phase number} — {phase name}
-> {executor's SUMMARY — brief commentary, decisions, implementation notes}
->
-> · · · · · · · · · · · ·
-> **Options:**
-> - **`y`/`yes`** — Approve, commit, continue to next task
-> - **`a`/`auto`** — Approve this and all future reviewer-approved tasks automatically
-> - **Comment** — Feedback the reviewer missed (triggers a fix round)
-> · · · · · · · · · · · ·
+**Task {id}: {Task Name} — approved**
+
+Phase: {phase number} — {phase name}
+{executor's SUMMARY — brief commentary, decisions, implementation notes}
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+**Options:**
+- **`y`/`yes`** — Approve, commit, continue to next task
+- **`a`/`auto`** — Approve this and all future reviewer-approved tasks automatically
+- **Comment** — Feedback the reviewer missed (triggers a fix round)
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user input.
 
@@ -153,7 +159,7 @@ Present a summary and wait for user input:
 
 Announce the result (one line, no stop):
 
-> **Task {id}: {Task Name} — approved** (phase {N}: {phase name}, {brief summary}). Committing.
+**Task {id}: {Task Name} — approved** (phase {N}: {phase name}, {brief summary}). Committing.
 
 → Proceed to **E. Update Progress and Commit**.
 
@@ -189,6 +195,6 @@ This is the end of this iteration.
 
 ## When All Tasks Are Complete
 
-> "All tasks complete. {M} tasks implemented."
+"All tasks complete. {M} tasks implemented."
 
 → Return to the skill for **Step 7**.

package/skills/technical-planning/SKILL.md

@@ -80,16 +80,18 @@ Note the current phase and task position from the `planning:` block.
 
 Load **[spec-change-detection.md](references/spec-change-detection.md)** to check whether the specification has changed since planning started. Then present the user with an informed choice:
 
-> Found existing plan for **{topic}** (previously reached phase {N}, task {M}).
->
-> {spec change summary from spec-change-detection.md}
->
-> · · · · · · · · · · · ·
-> - **`c`/`continue`** — Walk through the plan from the start. You can review, amend, or navigate at any point — including straight to the leading edge.
-> - **`r`/`restart`** — Erase all planning work for this topic and start fresh. This deletes the Plan Index File and any Authored Tasks. Other topics are unaffected.
-> · · · · · · · · · · · ·
+Found existing plan for **{topic}** (previously reached phase {N}, task {M}).
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+{spec change summary from spec-change-detection.md}
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+- **`c`/`continue`** — Walk through the plan from the start. You can review, amend, or navigate at any point — including straight to the leading edge.
+- **`r`/`restart`** — Erase all planning work for this topic and start fresh. This deletes the Plan Index File and any Authored Tasks. Other topics are unaffected.
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user response.
 
@@ -126,14 +128,16 @@ First, choose the Output Format.
 
 Present the recommendation:
 
-> Existing plans use **{format}**. Use the same format for consistency?
->
-> · · · · · · · · · · · ·
-> - **`y`/`yes`** — Use {format}
-> - **`n`/`no`** — See all available formats
-> · · · · · · · · · · · ·
+Existing plans use **{format}**. Use the same format for consistency?
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+- **`y`/`yes`** — Use {format}
+- **`n`/`no`** — See all available formats
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for user choice. If declined, fall through to the full list below.
 
@@ -231,10 +235,10 @@ After the review is complete:
 3. **Final commit** — Commit the concluded plan
 4. **Present completion summary**:
 
-> "Planning is complete for **{topic}**.
->
-> The plan contains **{N} phases** with **{M} tasks** total, reviewed for traceability against the specification and structural integrity.
->
-> Status has been marked as `concluded`. The plan is ready for implementation."
+"Planning is complete for **{topic}**.
+
+The plan contains **{N} phases** with **{M} tasks** total, reviewed for traceability against the specification and structural integrity.
+
+Status has been marked as `concluded`. The plan is ready for implementation."
 
 > **CHECKPOINT**: Do not conclude if any tasks in the Plan Index File show `status: pending`. All tasks must be `authored` before concluding.

package/skills/technical-planning/references/steps/analyze-task-graph.md

@@ -12,7 +12,7 @@ This step uses the `planning-dependency-grapher` agent (`../../../../agents/plan
 
 Orient the user:
 
-> "All tasks are authored. Now I'll analyze internal dependencies and priorities across the full plan."
+"All tasks are authored. Now I'll analyze internal dependencies and priorities across the full plan."
 
 Read **[output-formats.md](../output-formats.md)**, find the entry matching the `format:` field in the Plan Index File, and load the format's **[reading.md](../output-formats/{format}/reading.md)** and **[graph.md](../output-formats/{format}/graph.md)**.
 
@@ -34,17 +34,19 @@ The agent clears any existing dependencies/priorities, analyzes all tasks, and
 
 The natural task order is already correct. Present as rendered markdown (not in a code block):
 
-> "I've analyzed all {M} tasks and the natural execution order is already correct — no explicit dependencies or priorities are needed.
->
-> {notes from agent output}"
+"I've analyzed all {M} tasks and the natural execution order is already correct — no explicit dependencies or priorities are needed.
 
-> · · · · · · · · · · · ·
-> **To proceed:**
-> - **`y`/`yes`** — Confirmed.
-> - **Or tell me what to change.**
-> · · · · · · · · · · · ·
+{notes from agent output}"
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+**To proceed:**
+- **`y`/`yes`** — Confirmed.
+- **Or tell me what to change.**
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for the user's response.
 
@@ -52,11 +54,11 @@ The natural task order is already correct. Present as rendered markdown (not in
 
 No changes were applied. Present the cycle to the user:
 
-> "The dependency analysis found a circular dependency:
->
-> {cycle chain from agent output}
->
-> This must be resolved before continuing. The cycle usually means two tasks each assume the other is done first — one needs to be restructured or the dependency removed."
+"The dependency analysis found a circular dependency:
+
+{cycle chain from agent output}
+
+This must be resolved before continuing. The cycle usually means two tasks each assume the other is done first — one needs to be restructured or the dependency removed."
 
 **STOP.** Wait for the user to decide how to resolve. Options include adjusting task scope, merging tasks, or removing a dependency. Re-invoke the agent after changes.
 
@@ -64,23 +66,25 @@ No changes were applied. Present the cycle to the user:
 
 Dependencies and priorities have already been written to the task files. Present as rendered markdown (not in a code block):
 
-> "I've analyzed and applied dependencies and priorities across all {M} tasks:
->
-> **Dependencies** ({count} relationships):
-> {dependency list from agent output}
->
-> **Priorities**:
-> {priority list from agent output}
->
-> {any notes from agent output}"
-
-> · · · · · · · · · · · ·
-> **To proceed:**
-> - **`y`/`yes`** — Approved.
-> - **Or tell me what to change.**
-> · · · · · · · · · · · ·
-
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+"I've analyzed and applied dependencies and priorities across all {M} tasks:
+
+**Dependencies** ({count} relationships):
+{dependency list from agent output}
+
+**Priorities**:
+{priority list from agent output}
+
+{any notes from agent output}"
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+**To proceed:**
+- **`y`/`yes`** — Approved.
+- **Or tell me what to change.**
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for the user's response.
 

package/skills/technical-planning/references/steps/author-tasks.md

@@ -29,16 +29,18 @@ The agent returns complete task detail following the task template from task-des
 
 After presenting, ask:
 
-> **Task {M} of {total}: {Task Name}**
->
-> · · · · · · · · · · · ·
-> **To proceed:**
-> - **`y`/`yes`** — Approved. I'll log it to the plan.
-> - **Or tell me what to change.**
-> - **Or navigate** — a different phase or task, or the leading edge.
-> · · · · · · · · · · · ·
+**Task {M} of {total}: {Task Name}**
 
-**Do not wrap the above in a code block** — output as raw markdown so bold styling renders.
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+**To proceed:**
+- **`y`/`yes`** — Approved. I'll log it to the plan.
+- **Or tell me what to change.**
+- **Or navigate** — a different phase or task, or the leading edge.
+· · · · · · · · · · · ·
+```
 
 **STOP.** Wait for the user's response.
 
@@ -65,6 +67,6 @@ Present the revised task in full. Ask the same choice again. Repeat until approv
 
 Confirm:
 
-> "Task {M} of {total}: {Task Name} — authored."
+"Task {M} of {total}: {Task Name} — authored."
 
 → Return to **Plan Construction**.