@sixsevenai/ai-dlc-installer 1.2.6 → 1.3.0

package/library/commands/task/complete.md

@@ -0,0 +1,213 @@
+---
+command: task:complete
+description: Finalize a completed task plan — validates completion, optionally checks for code smells, writes a Complete.md summary, and commits.
+allowed-tools: Task, Read, Write, Edit, Glob, Grep, Bash, AskUserQuestion, TodoWrite, TodoRead, Skill
+args:
+  - name: --code-smells
+    description: Run a code smell analysis on files modified during the task before completing
+    required: false
+---
+
+# /task:complete
+
+Finalizes a completed task by verifying all steps are done, optionally auditing code quality, writing a completion summary (`Complete.md`), and committing the work.
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+---
+
+## Outline
+
+### Step 1: Locate and Load Task Plan
+
+1. Search for existing task plans:
+   ```
+   Glob: artifacts/tasks/*/task-plan.md
+   ```
+2. If **multiple** plans are found, select the most recently modified file.
+3. If **none** found, stop and report:
+   > "No task plan found. Run `/task:plan` first to create one."
+4. Read the complete task plan file using the Read tool.
+5. Parse `$ARGUMENTS` for the `--code-smells` flag.
+6. Report to the user: which task plan was loaded and which flags are active.
+
+---
+
+### Step 2: Validate Completion
+
+Scan every checkbox line in the task plan:
+
+| Symbol | Meaning |
+|--------|---------|
+| `[ ]` | Pending — not yet executed |
+| `[x]` | Complete |
+| `[SKIPPED]` | Skipped |
+| `[FAILED: ...]` | Failed |
+
+Count totals for each category.
+
+**Blocking checks:**
+
+- If **any** step is `[ ]` (pending), stop and report:
+  > "Task plan has {N} pending steps. Run `/task:execute` to complete them before finalizing."
+- If **any** step is `[FAILED: ...]`, ask the user with AskUserQuestion:
+  - **Proceed anyway** — accept failures and finalize
+  - **Stop** — go back and fix failures first
+
+If all steps are `[x]` or `[SKIPPED]` (with no failures, or user chose to proceed), continue.
+
+---
+
+### Step 3: Code Smell Check (optional — only if `--code-smells` flag present)
+
+If `--code-smells` was passed:
+
+1. Extract the list of modified/created files from the task plan's **Affected Files** section. Fall back to scanning the Execution Log for file paths mentioned in step notes.
+2. Use the **Skill** tool to invoke `simplify` — pass a prompt asking it to review the changed files for code smells, redundancy, and quality issues.
+   - If `simplify` is unavailable, use a general-purpose subagent via the **Task** tool with this prompt:
+     > "Review the following files for code smells, anti-patterns, unnecessary complexity, and obvious improvements. List findings by severity (high/medium/low). Do NOT make changes — report only. Files: {file-list}"
+3. Display the findings to the user.
+4. Ask with AskUserQuestion:
+   - **Fix all high-severity findings** — Spawn a subagent to address them
+   - **Fix all findings** — Spawn a subagent to address all severities
+   - **Skip fixes** — Continue without fixing
+
+If fixes are requested, spawn a subagent (Task tool) to apply them. After it returns, re-verify the task plan checkboxes to ensure nothing was broken.
+
+---
+
+### Step 4: Write `Complete.md`
+
+Determine the session folder from the task plan path (e.g., `artifacts/tasks/task-fix-auth-20260304-001/`).
+
+Write `artifacts/tasks/{session-id}/Complete.md` with this structure:
+
+```markdown
+# Task Complete: {TITLE from task plan}
+
+**Session**: {session-id}
+**Completed**: {today's date and time}
+**Status**: {Complete | Partial | Complete with failures accepted}
+
+---
+
+## Summary
+
+{Copy the Context section from the task plan — 1-3 sentences}
+
+---
+
+## Completion Statistics
+
+| Category | Count |
+|----------|-------|
+| Total steps | {N} |
+| Completed ✅ | {completed} |
+| Skipped ⏭️ | {skipped} |
+| Failed ❌ | {failed} |
+
+---
+
+## Files Modified
+
+{List of files from the task plan's Affected Files section, or extracted from the Execution Log}
+
+---
+
+## Code Smell Report
+
+{If --code-smells was run: paste findings summary here. If not run: "Not requested."}
+
+---
+
+## Execution Log
+
+{Copy the Execution Log table from the task plan}
+
+---
+
+## Rollback
+
+{Copy the Rollback Plan section from the task plan, or "See task-plan.md for rollback instructions."}
+```
+
+Use the **Write** tool to create the file.
+
+Verify it was created:
+```bash
+ls artifacts/tasks/{session-id}/Complete.md
+```
+
+---
+
+### Step 5: Commit
+
+Update the task plan's `**Status**:` field to `Complete` using the Edit tool.
+
+Then invoke the `/commit` skill using the **Skill** tool:
+```
+Skill: commit
+```
+
+This will stage all changes and create a properly formatted commit.
+
+---
+
+### Step 6: Report
+
+Output a final summary to the user:
+
+```
+## Task Finalized
+
+Session   : {session-id}
+Status    : {Complete | Partial | Complete with failures accepted}
+Summary   : {Complete.md path}
+Committed : ✅
+
+### Statistics
+- Completed : {N} steps
+- Skipped   : {N} steps
+- Failed    : {N} steps
+
+### Next Steps
+- Review Complete.md : artifacts/tasks/{session-id}/Complete.md
+- View task history  : artifacts/tasks/
+```
+
+---
+
+## Behavior Rules
+
+1. **Never finalize with pending steps.** Block and instruct the user to run `/task:execute` first.
+2. **Always write Complete.md before committing.** The file must exist before the commit runs.
+3. **Code smell check is optional.** Only run if `--code-smells` is in `$ARGUMENTS`.
+4. **Respect the user's choice on failures.** If they choose to proceed with failures, note it in `Complete.md` status.
+5. **Use the Skill tool for commit.** Invoke `commit` skill — do not run raw `git` commands.
+6. **Complete.md lives alongside task-plan.md.** Same session folder, same directory.
+
+---
+
+## Examples
+
+### Standard completion
+```bash
+/task:complete
+```
+
+### Completion with code smell review
+```bash
+/task:complete --code-smells
+```
+
+## Related Commands
+
+- `/task:plan` — Create a task plan
+- `/task:execute` — Execute the task plan (run before complete)
+- `/task:clarify` — Refine the plan

package/library/commands/task/execute.md

@@ -71,6 +71,26 @@ If the document does not yet contain an **Execution Log** table, append one at t
 |------|--------|-----------|-------|
 ```
 
+### Step 3.5: Build Claude TodoList
+
+Parse every checkbox step from the task plan and register them as Claude TodoList entries using the **TodoWrite** tool. This provides real-time progress visibility in the Claude UI during execution.
+
+**Parse rules:**
+- Create one TodoWrite entry per **subtask** (T1.1, T1.2, etc.) — not per individual atomic step. Atomic steps are tracked by checkboxes in the document; subtasks map cleanly to TodoList items.
+- Use the subtask label as the `subject` (e.g., `"T1.1 — Set up authentication middleware"`)
+- Set `activeForm` to a present-continuous version of the label (e.g., `"Setting up authentication middleware"`)
+- Set `status` to `pending` for all entries initially.
+- Set `description` to the list of atomic step IDs within that subtask (e.g., `"Steps: T1.1.1, T1.1.2, T1.1.3"`)
+
+**If the task plan has no subtasks** (only top-level tasks), create one TodoList entry per top-level task instead.
+
+**After creating entries**, store the mapping of `{subtask-id → todoId}` in working memory so you can update each entry's status as steps execute.
+
+**During execution** (Steps 4A and 4B), update each TodoList entry via **TaskUpdate** equivalent behavior:
+- When the first step of a subtask begins executing: mark the entry `in_progress`
+- When all steps in a subtask are `[x]` or `[SKIPPED]`: mark the entry `completed`
+- When a subtask step is `[FAILED: ...]` and the user chose to move on: mark the entry `completed` (failures are logged in the document)
+
 ### Step 4A: Interactive Execution (default mode)
 
 For each **top-level task** (T1, T2, T3, ...) that contains at least one pending `[ ]` step:
@@ -209,7 +229,7 @@ Update the task plan document with final state:
 ```
 
 If all steps passed, suggest:
-- Committing the changes: `git add . && git commit -m "task: {plan summary}"`
+- Running `/task:complete` to finalize, generate `Complete.md`, and commit in one step
 - Running related commands if applicable
 
 If there were failures, suggest:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sixsevenai/ai-dlc-installer",
-  "version": "1.2.6",
+  "version": "1.3.0",
   "description": "Interactive terminal installer for the AI-DLC framework",
   "type": "module",
   "license": "MIT",