maxsimcli 5.0.6 → 5.1.0

package/dist/assets/templates/workflows/quick.md

@@ -1,29 +1,14 @@
-<sanity_check>
-Before executing any step in this workflow, verify:
-1. The current directory contains a `.planning/` folder — if not, stop and tell the user to run `/maxsim:init` first.
-2. `.planning/ROADMAP.md` exists — if not, stop and tell the user to initialize the project.
-</sanity_check>
-
 <purpose>
-Execute small, ad-hoc tasks with MAXSIM guarantees (atomic commits, STATE.md tracking).
-
-Quick mode spawns planner (quick mode) + executor(s), tracks tasks as GitHub Issues (label: "quick"), and updates STATE.md's "Quick Tasks Completed" table.
-
-With `--full` flag: enables plan-checking (max 2 iterations) and post-execution verification for quality guarantees without full milestone ceremony.
+Simplified flow for small tasks that don't need full phase planning. Creates a GitHub Issue, executes the task directly, runs verification, commits, and closes the issue.
 </purpose>
 
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-
 <process>
-**Step 1: Parse arguments and detect mode**
 
-Parse `$ARGUMENTS` for:
-- `--full` flag → store as `$FULL_MODE` (true/false)
-- Remaining text → use as `$DESCRIPTION` if non-empty
+## Step 1: Get task description
+
+Parse `$ARGUMENTS` for task description text.
 
-If `$DESCRIPTION` is empty after parsing, prompt user interactively:
+If empty, prompt:
 
 ```
 AskUserQuestion(
@@ -33,550 +18,140 @@ AskUserQuestion(
 )
 ```
 
-Store response as `$DESCRIPTION`.
-
-If still empty, re-prompt: "Please provide a task description."
-
-If `$FULL_MODE`:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- MAXSIM ► QUICK TASK (FULL MODE)
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-◆ Plan checking + verification enabled
-```
+Store as `$DESCRIPTION`. If still empty, re-prompt: "Please provide a task description."
 
 ---
 
-**Step 2: Initialize**
+## Step 2: Create GitHub Issue
 
 ```bash
-INIT=$(node ~/.claude/maxsim/bin/maxsim-tools.cjs init quick "$DESCRIPTION")
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github create-issue \
+  --title "$DESCRIPTION" \
+  --label "type:quick" \
+  --body "Quick task: $DESCRIPTION"
 ```
 
-Parse JSON for: `planner_model`, `executor_model`, `checker_model`, `verifier_model`, `commit_docs`, `next_num`, `slug`, `date`, `timestamp`, `quick_dir`, `task_dir`, `roadmap_exists`, `planning_exists`.
+Parse JSON response for `issue_number`. Store as `$ISSUE_NUM`.
 
-**If `roadmap_exists` is false:** Error — Quick mode requires an active project with ROADMAP.md. Run `/maxsim:init` first.
-
-Quick tasks can run mid-phase - validation only checks ROADMAP.md exists, not phase status.
-
----
-
-**Step 3: Create task directory**
+Move issue to "In Progress" on the project board:
 
 ```bash
-mkdir -p "${task_dir}"
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github move-issue \
+  --issue-number $ISSUE_NUM \
+  --status "In Progress"
 ```
 
----
-
-**Step 4: Create quick task directory**
+Display:
 
-Create the directory for this quick task:
-
-```bash
-QUICK_DIR=".planning/quick/${next_num}-${slug}"
-mkdir -p "$QUICK_DIR"
-```
-
-Report to user:
-```
-Creating quick task ${next_num}: ${DESCRIPTION}
-Directory: ${QUICK_DIR}
-```
-
-Store `$QUICK_DIR` for use in orchestration.
-
----
-
-**Step 5: Spawn planner (quick mode)**
-
-**If `$FULL_MODE`:** Use `quick-full` mode with stricter constraints.
-
-**If NOT `$FULL_MODE`:** Use standard `quick` mode.
-
-```
-Task(
-  prompt="
-<planning_context>
-
-**Mode:** ${FULL_MODE ? 'quick-full' : 'quick'}
-**Directory:** ${QUICK_DIR}
-**Description:** ${DESCRIPTION}
-
-<files_to_read>
-- .planning/STATE.md (Project State)
-- ./CLAUDE.md (if exists — follow project-specific guidelines)
-</files_to_read>
-
-**Project skills:** Check .skills/ directory (if exists) — read SKILL.md files, plans should account for project skill rules
-
-</planning_context>
-
-<constraints>
-- Create a SINGLE plan with 1-3 focused tasks
-- Quick tasks should be atomic and self-contained
-- No research phase
-${FULL_MODE ? '- Target ~40% context usage (structured for verification)' : '- Target ~30% context usage (simple, focused)'}
-${FULL_MODE ? '- MUST generate `must_haves` in plan frontmatter (truths, artifacts, key_links)' : ''}
-${FULL_MODE ? '- Each task MUST have `files`, `action`, `verify`, `done` fields' : ''}
-</constraints>
-
-<output>
-Write plan to: ${QUICK_DIR}/${next_num}-PLAN.md
-Return: ## PLANNING COMPLETE with plan path
-</output>
-",
-  subagent_type="planner",
-  model="{planner_model}",
-  description="Quick plan: ${DESCRIPTION}"
-)
-```
-
-After planner returns:
-1. Verify plan exists at `${QUICK_DIR}/${next_num}-PLAN.md`
-2. Extract plan count (typically 1 for quick tasks)
-3. Report: "Plan created: ${QUICK_DIR}/${next_num}-PLAN.md"
-
-If plan not found, error: "Planner failed to create ${next_num}-PLAN.md"
-
----
-
-**Step 5.5: Plan-checker loop (only when `$FULL_MODE`)**
-
-Skip this step entirely if NOT `$FULL_MODE`.
-
-Display banner:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- MAXSIM ► CHECKING PLAN
+ MAXSIM ► QUICK TASK #$ISSUE_NUM
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-◆ Spawning plan checker...
-```
-
-Checker prompt:
-
-```markdown
-<verification_context>
-**Mode:** quick-full
-**Task Description:** ${DESCRIPTION}
-
-<files_to_read>
-- ${QUICK_DIR}/${next_num}-PLAN.md (Plan to verify)
-</files_to_read>
-
-**Scope:** This is a quick task, not a full phase. Skip checks that require a ROADMAP phase goal.
-</verification_context>
-
-<check_dimensions>
-- Requirement coverage: Does the plan address the task description?
-- Task completeness: Do tasks have files, action, verify, done fields?
-- Key links: Are referenced files real?
-- Scope sanity: Is this appropriately sized for a quick task (1-3 tasks)?
-- must_haves derivation: Are must_haves traceable to the task description?
-
-Skip: context compliance (no CONTEXT.md), cross-plan deps (single plan), ROADMAP alignment
-</check_dimensions>
-
-<expected_output>
-- ## VERIFICATION PASSED — all checks pass
-- ## ISSUES FOUND — structured issue list
-</expected_output>
-```
-
-```
-Task(
-  prompt="## Task: Verify plans achieve phase goal\n\n## Suggested Skills: verification-gates\n\n" + checker_prompt,
-  subagent_type="planner",
-  model="{checker_model}",
-  description="Check quick plan: ${DESCRIPTION}"
-)
-```
-
-**Handle checker return:**
-
-- **`## VERIFICATION PASSED`:** Display confirmation, proceed to step 6.
-- **`## ISSUES FOUND`:** Display issues, check iteration count, enter revision loop.
-
-**Revision loop (max 2 iterations):**
-
-Track `iteration_count` (starts at 1 after initial plan + check).
-
-**If iteration_count < 2:**
-
-Display: `Sending back to planner for revision... (iteration ${N}/2)`
-
-Revision prompt:
-
-```markdown
-<revision_context>
-**Mode:** quick-full (revision)
-
-<files_to_read>
-- ${QUICK_DIR}/${next_num}-PLAN.md (Existing plan)
-</files_to_read>
-
-**Checker issues:** ${structured_issues_from_checker}
-
-</revision_context>
-
-<instructions>
-Make targeted updates to address checker issues.
-Do NOT replan from scratch unless issues are fundamental.
-Return what changed.
-</instructions>
+Task: $DESCRIPTION
+Issue: #$ISSUE_NUM (In Progress)
 ```
 
-```
-Task(
-  prompt=revision_prompt,
-  subagent_type="planner",
-  model="{planner_model}",
-  description="Revise quick plan: ${DESCRIPTION}"
-)
-```
-
-After planner returns → spawn checker again, increment iteration_count.
-
-**If iteration_count >= 2:**
-
-Display: `Max iterations reached. ${N} issues remain:` + issue list
-
-Offer: 1) Force proceed, 2) Abort
-
 ---
 
-**Step 6: Spawn executor**
+## Step 3: Execute the task
 
-Spawn executor with plan reference:
+Spawn an executor agent to implement the task directly — no wave scheduling, no plan files:
 
 ```
-Task(
+Agent(
   prompt="
-Execute quick task ${next_num}.
+Execute this task: $DESCRIPTION
 
-<files_to_read>
-- ${QUICK_DIR}/${next_num}-PLAN.md (Plan)
-- .planning/STATE.md (Project state)
-- ./CLAUDE.md (Project instructions, if exists)
-- .skills/ (Project skills, if exists — list skills, read SKILL.md for each, follow relevant rules during implementation)
-</files_to_read>
+GitHub Issue: #$ISSUE_NUM
 
 <constraints>
-- Execute all tasks in the plan
-- Commit each task atomically
-- Create summary at: ${QUICK_DIR}/${next_num}-SUMMARY.md
-- Do NOT update ROADMAP.md (quick tasks are separate from planned phases)
+- Implement the task fully
+- Commit changes atomically with message: feat(quick-#$ISSUE_NUM): $DESCRIPTION
+- Do NOT create .planning/ files (quick tasks skip phase ceremony)
+- Return a short summary of what was done and the commit hash
 </constraints>
 ",
   subagent_type="executor",
-  model="{executor_model}",
-  description="Execute: ${DESCRIPTION}"
+  description="Execute quick task #$ISSUE_NUM: $DESCRIPTION"
 )
 ```
 
-After executor returns:
-1. Verify summary exists at `${QUICK_DIR}/${next_num}-SUMMARY.md`
-2. Extract commit hash from executor output
-3. Report completion status
-
-**Known Claude Code bug (classifyHandoffIfNeeded):** If executor reports "failed" with error `classifyHandoffIfNeeded is not defined`, this is a Claude Code runtime bug — not a real failure. Check if summary file exists and git log shows commits. If so, treat as successful.
-
-If summary not found, error: "Executor failed to create ${next_num}-SUMMARY.md"
-
-Note: For quick tasks producing multiple plans (rare), spawn executors in parallel waves per execute-phase patterns.
+Extract `$COMMIT_HASH` and `$SUMMARY` from executor output.
 
 ---
 
-**Step 6.3: Two-Stage Review**
-
-Run spec-compliance and code-quality review on the completed quick task. This applies to ALL quick tasks regardless of model profile or `--full` flag (per locked decision: "Quick means fast planning, not skipped quality gates").
-
-Display banner:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- MAXSIM ► REVIEWING RESULTS
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-◆ Running two-stage review...
-```
-
-1. Read the completed SUMMARY.md from `${QUICK_DIR}/${next_num}-SUMMARY.md` to understand what was built.
-2. Get modified files: `git diff --name-only HEAD~{N}` where N = number of commits from the executor.
-3. Read the quick plan at `${QUICK_DIR}/${next_num}-PLAN.md` to get task specs.
-
-**Spec Review:**
-
-```
-Task(
-  prompt="
-    ## Task: Review for spec compliance
-
-    ## Suggested Skills: verification-gates, evidence-collection
-
-    <review_context>
-    **Plan:** quick-${next_num}
-    **Description:** ${DESCRIPTION}
-
-    <task_specs>
-    {Copy task specs (action, done criteria, files) from ${QUICK_DIR}/${next_num}-PLAN.md}
-    </task_specs>
-
-    <modified_files>
-    {output of git diff --name-only HEAD~N}
-    </modified_files>
-
-    <plan_frontmatter>
-    {Plan frontmatter including requirements if present}
-    </plan_frontmatter>
-    </review_context>
-  ",
-  subagent_type="verifier",
-  model="{executor_model}",
-  description="Spec review: ${DESCRIPTION}"
-)
-```
-
-Parse output frontmatter for `status:` field.
-If FAIL: fix issues, commit (`fix(quick-${next_num}): address spec review findings`), retry (max 2 retries).
-On retry exhaustion (3 total attempts):
-
-```
-## REVIEW BLOCKED
-
-**Stage:** Spec Compliance
-**Task:** quick-${next_num}: ${DESCRIPTION}
-**Attempts:** 3 (initial + 2 retries)
-**Failing Issues:**
-- {issue list from review}
-
-**Options:**
-1. Fix manually and continue
-2. Skip review for this task
-3. Abort execution
-```
+## Step 4: Verify
 
-STOP and wait for user decision.
-
-**Code Review:**
+Run a focused verification of the completed work:
 
 ```
-Task(
+Agent(
   prompt="
-    ## Task: Review for code quality
-
-    ## Suggested Skills: code-review
-
-    <review_context>
-    **Plan:** quick-${next_num}
+Verify this quick task was completed correctly:
 
-    <modified_files>
-    {output of git diff --name-only HEAD~N, updated after any spec-review fix commits}
-    </modified_files>
+Task: $DESCRIPTION
+GitHub Issue: #$ISSUE_NUM
+Commit: $COMMIT_HASH
 
-    <conventions>
-    {Content of .planning/CONVENTIONS.md or .planning/codebase/CONVENTIONS.md, or 'No CONVENTIONS.md found'}
-    </conventions>
+Check:
+1. Does the implementation match the task description?
+2. Are there any obvious issues or regressions?
 
-    <test_results>
-    {Last 20 lines of npm test output if package.json exists, or 'No tests available'}
-    </test_results>
-    </review_context>
-  ",
+Return: PASS or FAIL with brief reasoning.
+",
   subagent_type="verifier",
-  model="{executor_model}",
-  description="Code review: ${DESCRIPTION}"
+  description="Verify quick task #$ISSUE_NUM"
 )
 ```
 
-Same retry logic as spec review (max 2 retries, then REVIEW BLOCKED with user options).
-
-**Record review results** in the quick task SUMMARY.md:
+Store `$VERIFY_STATUS` (PASS or FAIL).
 
-Append `## Review Cycle` section to `${QUICK_DIR}/${next_num}-SUMMARY.md`:
-```markdown
-## Review Cycle
-- Spec: {PASS/FAIL/SKIPPED} ({retry_count} retries)
-- Code: {PASS/FAIL/SKIPPED} ({retry_count} retries)
-- Issues: {critical_count} critical, {warning_count} warnings
-```
-
-If `--full` flag was set: this review is part of the full quality pipeline (alongside plan-checking and verification that `--full` already enables).
-If `--full` was NOT set: the review STILL runs (per locked decision).
+If FAIL: display issues, ask user whether to fix or accept as-is.
 
 ---
 
-**Step 6.5: Verification (only when `$FULL_MODE`)**
-
-Skip this step entirely if NOT `$FULL_MODE`.
-
-Display banner:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- MAXSIM ► VERIFYING RESULTS
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-◆ Spawning verifier...
-```
-
-```
-Task(
-  prompt="Verify quick task goal achievement.
-Task directory: ${QUICK_DIR}
-Task goal: ${DESCRIPTION}
+## Step 5: Commit artifacts, close issue, move to Done
 
-<files_to_read>
-- ${QUICK_DIR}/${next_num}-PLAN.md (Plan)
-</files_to_read>
+Post completion comment to the issue:
 
-Check must_haves against actual codebase. Create VERIFICATION.md at ${QUICK_DIR}/${next_num}-VERIFICATION.md.",
-  subagent_type="verifier",
-  model="{verifier_model}",
-  description="Verify: ${DESCRIPTION}"
-)
-```
-
-Read verification status:
 ```bash
-grep "^status:" "${QUICK_DIR}/${next_num}-VERIFICATION.md" | cut -d: -f2 | tr -d ' '
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github comment-issue \
+  --issue-number $ISSUE_NUM \
+  --body "Completed. Commit: $COMMIT_HASH\n\nSummary: $SUMMARY\n\nVerification: $VERIFY_STATUS"
 ```
 
-Store as `$VERIFICATION_STATUS`.
-
-| Status | Action |
-|--------|--------|
-| `passed` | Store `$VERIFICATION_STATUS = "Verified"`, continue to step 7 |
-| `human_needed` | Display items needing manual check, store `$VERIFICATION_STATUS = "Needs Review"`, continue |
-| `gaps_found` | Display gap summary, offer: 1) Re-run executor to fix gaps, 2) Accept as-is. Store `$VERIFICATION_STATUS = "Gaps"` |
-
----
-
-**Step 7: Update STATE.md**
-
-Update STATE.md with quick task completion record.
-
-**7a. Check if "Quick Tasks Completed" section exists:**
-
-Read STATE.md and check for `### Quick Tasks Completed` section.
-
-**7b. If section doesn't exist, create it:**
-
-Insert after `### Blockers/Concerns` section:
-
-**If `$FULL_MODE`:**
-```markdown
-### Quick Tasks Completed
-
-| # | Description | Date | Commit | Status | Directory |
-|---|-------------|------|--------|--------|-----------|
-```
-
-**If NOT `$FULL_MODE`:**
-```markdown
-### Quick Tasks Completed
-
-| # | Description | Date | Commit | Directory |
-|---|-------------|------|--------|-----------|
-```
-
-**Note:** If the table already exists, match its existing column format. If adding `--full` to a project that already has quick tasks without a Status column, add the Status column to the header and separator rows, and leave Status empty for the new row's predecessors.
-
-**7c. Append new row to table:**
-
-Use `date` from init:
-
-**If `$FULL_MODE` (or table has Status column):**
-```markdown
-| ${next_num} | ${DESCRIPTION} | ${date} | ${commit_hash} | ${VERIFICATION_STATUS} | [${next_num}-${slug}](./quick/${next_num}-${slug}/) |
-```
-
-**If NOT `$FULL_MODE` (and table has no Status column):**
-```markdown
-| ${next_num} | ${DESCRIPTION} | ${date} | ${commit_hash} | [${next_num}-${slug}](./quick/${next_num}-${slug}/) |
-```
-
-**7d. Update "Last activity" line:**
-
-Use `date` from init:
-```
-Last activity: ${date} - Completed quick task ${next_num}: ${DESCRIPTION}
-```
-
-Use Edit tool to make these changes atomically
-
----
-
-**Step 8: Final commit and completion**
-
-Stage and commit quick task artifacts:
-
-Build file list:
-- `${QUICK_DIR}/${next_num}-PLAN.md`
-- `${QUICK_DIR}/${next_num}-SUMMARY.md`
-- `.planning/STATE.md`
-- If `$FULL_MODE` and verification file exists: `${QUICK_DIR}/${next_num}-VERIFICATION.md`
+Close the issue and move to Done:
 
 ```bash
-node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "docs(quick-${next_num}): ${DESCRIPTION}" --files ${file_list}
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github close-issue --issue-number $ISSUE_NUM
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github move-issue \
+  --issue-number $ISSUE_NUM \
+  --status "Done"
 ```
 
-Get final commit hash:
-```bash
-commit_hash=$(git rev-parse --short HEAD)
-```
-
-Display completion output:
-
-**If `$FULL_MODE`:**
-```
----
+Display:
 
-MAXSIM > QUICK TASK COMPLETE (FULL MODE)
-
-Quick Task ${next_num}: ${DESCRIPTION}
-
-Summary: ${QUICK_DIR}/${next_num}-SUMMARY.md
-Verification: ${QUICK_DIR}/${next_num}-VERIFICATION.md (${VERIFICATION_STATUS})
-Commit: ${commit_hash}
-
----
-
-Ready for next task: /maxsim:quick
 ```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ MAXSIM ► QUICK TASK COMPLETE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-**If NOT `$FULL_MODE`:**
-```
----
-
-MAXSIM > QUICK TASK COMPLETE
-
-Quick Task ${next_num}: ${DESCRIPTION}
-
-Summary: ${QUICK_DIR}/${next_num}-SUMMARY.md
-Commit: ${commit_hash}
-
----
+Task: $DESCRIPTION
+Issue: #$ISSUE_NUM (Done)
+Commit: $COMMIT_HASH
+Verification: $VERIFY_STATUS
 
 Ready for next task: /maxsim:quick
 ```
 
----
-
 </process>
 
 <success_criteria>
-**Quick Task Mode:**
-- [ ] ROADMAP.md validation passes
-- [ ] User provides task description
-- [ ] `--full` flag parsed from arguments when present
-- [ ] Slug generated (lowercase, hyphens, max 40 chars)
-- [ ] Next number calculated (001, 002, 003...)
-- [ ] Directory created at `.planning/quick/NNN-slug/`
-- [ ] `${next_num}-PLAN.md` created by planner
-- [ ] (--full) Plan checker validates plan, revision loop capped at 2
-- [ ] `${next_num}-SUMMARY.md` created by executor
-- [ ] (--full) `${next_num}-VERIFICATION.md` created by verifier
-- [ ] STATE.md updated with quick task row (Status column when --full)
-- [ ] Artifacts committed
+- [ ] GitHub Issue created with label "type:quick"
+- [ ] Issue moved to "In Progress" on project board
+- [ ] Task executed directly (no plan files)
+- [ ] Verification run and result recorded
+- [ ] Completion comment posted to issue
+- [ ] Issue closed and moved to "Done"
 </success_criteria>