maxsimcli 4.16.0 → 5.0.0

package/dist/assets/templates/workflows/execute-plan.md

@@ -9,15 +9,7 @@ Read config.json for planning behavior settings.
 @./references/git-integration.md
 </required_reading>
 
-## MCP Server Fallback
-
-MAXSIM provides MCP tools (mcp_create_phase, mcp_list_phases, etc.) for structured operations.
-If MCP tools are available in your tool list, prefer them for phase, todo, and state operations.
-
-**If MCP tools are NOT available** (server not running, .mcp.json not configured, or non-Claude runtime):
-- Log a warning: "MCP server not available -- using Bash tools router fallback"
-- Fall back to the Bash tools router: `node .claude/maxsim/bin/maxsim-tools.cjs <command>`
-- All operations work identically via either path -- MCP is preferred but not required
+MAXSIM provides CLI commands (`github create-phase`, `github list-phases`, etc.) for structured operations.
 
 <process>
 
@@ -45,8 +37,8 @@ When the orchestrator passes `github_context` (phase_issue_number and plan_comme
 
 **External edit detection (WIRE-06):** Before beginning execution, check if the plan comment was modified since the orchestrator read it:
 
-```
-mcp_detect_external_edits(issue_number: phase_issue_number)
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github detect-external-edits --phase-number "$PHASE_NUMBER"
 ```
 
 If external edits detected: warn user and offer to re-read the plan before proceeding.
@@ -120,7 +112,7 @@ Pattern B only (verify-only checkpoints). Skip for A/C.
 2. Per segment:
    - Subagent route: spawn executor for assigned tasks only. Prompt: task range, plan content (from GitHub comment or local path), read full plan for context, execute assigned tasks, track deviations, move task sub-issues to "In Progress" when started and "Done" when completed, NO SUMMARY/commit. Track via agent protocol.
    - Main route: execute tasks using standard flow (step name="execute")
-3. After ALL segments: aggregate files/deviations/decisions → post SUMMARY as GitHub comment (mcp_post_comment with type=summary) → commit → self-check:
+3. After ALL segments: aggregate files/deviations/decisions → post SUMMARY as GitHub comment (`github post-comment` with type=summary) → commit → self-check:
    - Verify key-files.created exist on disk with `[ -f ]`
    - Check `git log --oneline --all --grep="{phase}-{plan}"` returns ≥1 commit
    - Check for `## Self-Check: PASSED` or `## Self-Check: FAILED` and append to summary comment body
@@ -188,8 +180,8 @@ Deviations are normal — handle via rules below.
    **Before starting each task (WIRE-04 board transition):**
    - Look up the task's sub-issue number from `task_mappings` in the GitHub context.
    - Move the task sub-issue to "In Progress":
-     ```
-     mcp_move_issue(issue_number: task_sub_issue_number, status: "In Progress")
+     ```bash
+     node ~/.claude/maxsim/bin/maxsim-tools.cjs github move-issue --issue-number $TASK_SUB_ISSUE_NUMBER --status "In Progress"
      ```
 
    - `type="auto"`: if `tdd="true"` → TDD execution. Implement with deviation rules + auth gates. Verify done criteria. Commit (see task_commit). Track hash for Summary.
@@ -197,17 +189,13 @@ Deviations are normal — handle via rules below.
 
    **After each task completes successfully (WIRE-04 board transition):**
    - Post task completion details on the task sub-issue:
-     ```
-     mcp_post_completion(
-       issue_number: task_sub_issue_number,
-       commit_sha: TASK_COMMIT,
-       files_changed: [list of files modified by this task]
-     )
+     ```bash
+     node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-completion --issue-number $TASK_SUB_ISSUE_NUMBER --commit-sha "$TASK_COMMIT" --files-changed "file1.ts,file2.ts"
      ```
    - Close the task sub-issue and move to "Done":
-     ```
-     mcp_close_issue(issue_number: task_sub_issue_number)
-     mcp_move_issue(issue_number: task_sub_issue_number, status: "Done")
+     ```bash
+     node ~/.claude/maxsim/bin/maxsim-tools.cjs github close-issue $TASK_SUB_ISSUE_NUMBER
+     node ~/.claude/maxsim/bin/maxsim-tools.cjs github move-issue --issue-number $TASK_SUB_ISSUE_NUMBER --status "Done"
      ```
 
 3. Run `<verification>` checks
@@ -362,13 +350,19 @@ Orchestrator parses → presents to user → spawns fresh continuation with your
 If verification fails: STOP. Present: "Verification failed for Task [X]: [name]. Expected: [criteria]. Actual: [result]." Options: Retry | Skip (mark incomplete) | Stop (investigate). If skipped → SUMMARY "Issues Encountered".
 
 **On review failure (WIRE-07):** If the task sub-issue was already moved to "Done", reopen and move back:
-```
-mcp_reopen_issue(issue_number: task_sub_issue_number)
-mcp_move_issue(issue_number: task_sub_issue_number, status: "In Progress")
-mcp_post_comment(
-  issue_number: task_sub_issue_number,
-  body: "## Review Failure\n\nVerification failed for this task. Moving back to In Progress.\n\n**Reason:** {failure details}\n**Action needed:** {what needs to be fixed}"
-)
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github reopen-issue $TASK_SUB_ISSUE_NUMBER
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github move-issue --issue-number $TASK_SUB_ISSUE_NUMBER --status "In Progress"
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'BODY_EOF'
+## Review Failure
+
+Verification failed for this task. Moving back to In Progress.
+
+**Reason:** {failure details}
+**Action needed:** {what needs to be fixed}
+BODY_EOF
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $TASK_SUB_ISSUE_NUMBER --body-file "$TMPFILE"
 ```
 </step>
 
@@ -394,11 +388,17 @@ fi
 If plan frontmatter contains a `user_setup` field: create `{phase}-USER-SETUP.md` using template `~/.claude/maxsim/templates/user-setup.md`. Per service: env vars table, account setup checklist, dashboard config, local dev notes, verification commands. Status "Incomplete". Set `USER_SETUP_CREATED=true`. If empty/missing: skip.
 
 Also post a reminder comment on the phase issue:
-```
-mcp_post_comment(
-  issue_number: phase_issue_number,
-  body: "## User Setup Required\n\nThis plan created a USER-SETUP.md with manual steps needed before proceeding.\n\n**File:** {phase}-USER-SETUP.md\n**Services:** {list of services requiring setup}"
-)
+```bash
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'BODY_EOF'
+## User Setup Required
+
+This plan created a USER-SETUP.md with manual steps needed before proceeding.
+
+**File:** {phase}-USER-SETUP.md
+**Services:** {list of services requiring setup}
+BODY_EOF
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $PHASE_ISSUE_NUMBER --body-file "$TMPFILE"
 ```
 </step>
 
@@ -422,12 +422,10 @@ Build summary content using the same structure as `~/.claude/maxsim/templates/su
 - Self-Check result
 
 Post to the phase issue:
-```
-mcp_post_comment(
-  issue_number: phase_issue_number,
-  type: "summary",
-  body: {summary_content}
-)
+```bash
+TMPFILE=$(mktemp)
+echo "$SUMMARY_CONTENT" > "$TMPFILE"
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $PHASE_ISSUE_NUMBER --body-file "$TMPFILE" --type summary
 ```
 
 Record the comment URL/ID as `SUMMARY_COMMENT_ID` for future reference.
@@ -597,13 +595,19 @@ Wait for user response:
 **On review failure -- reopen affected task sub-issues (WIRE-07):**
 
 If the code review identifies failures tied to specific tasks, and those task sub-issues were already closed:
-```
-mcp_reopen_issue(issue_number: task_sub_issue_number)
-mcp_move_issue(issue_number: task_sub_issue_number, status: "In Progress")
-mcp_post_comment(
-  issue_number: task_sub_issue_number,
-  body: "## Code Review Failure\n\nThis task's code review was blocked. Moving back to In Progress.\n\n**Blocking issues:**\n{list of blocker/high issues from verifier}"
-)
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github reopen-issue $TASK_SUB_ISSUE_NUMBER
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github move-issue --issue-number $TASK_SUB_ISSUE_NUMBER --status "In Progress"
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'BODY_EOF'
+## Code Review Failure
+
+This task's code review was blocked. Moving back to In Progress.
+
+**Blocking issues:**
+{list of blocker/high issues from verifier}
+BODY_EOF
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $TASK_SUB_ISSUE_NUMBER --body-file "$TMPFILE"
 ```
 
 ---
@@ -886,12 +890,10 @@ Add review cycle results to the summary content in memory (under a `## Review Cy
 ```
 
 Now post the complete summary (with review cycle included) to GitHub:
-```
-mcp_post_comment(
-  issue_number: phase_issue_number,
-  type: "summary",
-  body: {complete_summary_content_including_review_cycle}
-)
+```bash
+TMPFILE=$(mktemp)
+echo "$COMPLETE_SUMMARY_CONTENT" > "$TMPFILE"
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $PHASE_ISSUE_NUMBER --body-file "$TMPFILE" --type summary
 ```
 
 After posting, commit any review-cycle metadata:
@@ -1003,22 +1005,34 @@ If the plan includes verification criteria (from `<verification>` section of pla
 
 Build verification results content in memory with `<!-- maxsim:type=verification -->` marker.
 
-```
-mcp_post_comment(
-  issue_number: phase_issue_number,
-  type: "verification",
-  body: "<!-- maxsim:type=verification -->\n## Plan {plan_number} Verification\n\n{verification_results}\n\n**Status:** {passed|failed}\n**Timestamp:** {ISO timestamp}"
-)
+```bash
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'BODY_EOF'
+<!-- maxsim:type=verification -->
+## Plan {plan_number} Verification
+
+{verification_results}
+
+**Status:** {passed|failed}
+**Timestamp:** {ISO timestamp}
+BODY_EOF
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $PHASE_ISSUE_NUMBER --body-file "$TMPFILE" --type verification
 ```
 
 If the plan includes UAT criteria (from `<uat>` section):
 
-```
-mcp_post_comment(
-  issue_number: phase_issue_number,
-  type: "uat",
-  body: "<!-- maxsim:type=uat -->\n## Plan {plan_number} UAT\n\n{uat_criteria_and_results}\n\n**Status:** {pending|passed|failed}\n**Timestamp:** {ISO timestamp}"
-)
+```bash
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'BODY_EOF'
+<!-- maxsim:type=uat -->
+## Plan {plan_number} UAT
+
+{uat_criteria_and_results}
+
+**Status:** {pending|passed|failed}
+**Timestamp:** {ISO timestamp}
+BODY_EOF
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $PHASE_ISSUE_NUMBER --body-file "$TMPFILE" --type uat
 ```
 
 GitHub Issues is the source of truth -- verification and UAT results are always posted as GitHub comments.
@@ -1043,8 +1057,8 @@ node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "" --files .planning/codebase/
 If `USER_SETUP_CREATED=true`: display `⚠️ USER SETUP REQUIRED` with path + env/config tasks at TOP.
 
 Check completion by querying the phase issue's task sub-issues:
-```
-mcp_list_sub_issues(issue_number: phase_issue_number)
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github list-sub-issues $PHASE_ISSUE_NUMBER
 ```
 
 Count open vs closed sub-issues. Map closed count to plans complete.

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

@@ -41,8 +41,8 @@ Exit workflow.
 
 When GitHub integration is active (phase_issue_number is set), check for plan comments on the phase issue before reporting no plans:
 
-```
-mcp_get_issue_detail(issue_number: phase_issue_number)
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github get-issue $PHASE_ISSUE_NUMBER --comments
 ```
 
 Parse the response to find comments with `<!-- maxsim:type=plan -->` markers or `## Plan NN` headings. If no plan comments are found:
@@ -61,8 +61,8 @@ Exit workflow.
 When GitHub integration is active (`phase_issue_number` is set):
 
 1. Fetch the phase issue and its comments:
-   ```
-   mcp_get_issue_detail(issue_number: phase_issue_number)
+   ```bash
+   node ~/.claude/maxsim/bin/maxsim-tools.cjs github get-issue $PHASE_ISSUE_NUMBER --comments
    ```
 
 2. Parse issue comments to identify plan comments. A plan comment is one that contains either:
@@ -75,8 +75,8 @@ When GitHub integration is active (`phase_issue_number` is set):
    - Store plan content in memory as `PLAN_COMMENTS[]`
 
 4. Check completion status for each plan by calling:
-   ```
-   mcp_list_sub_issues(issue_number: phase_issue_number)
+   ```bash
+   node ~/.claude/maxsim/bin/maxsim-tools.cjs github list-sub-issues $PHASE_ISSUE_NUMBER
    ```
    A plan is considered complete when ALL of its task sub-issues are closed (state: closed).
    Additionally, check for `<!-- maxsim:type=summary -->` comments on the phase issue as a secondary completion signal.
@@ -99,8 +99,8 @@ Exit workflow.
 
 If phase_issue_number is set, optionally detect whether the phase issue was externally modified since last read:
 
-```
-mcp_detect_external_edits(issue_number: phase_issue_number)
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github detect-external-edits --phase-number "$PHASE_NUMBER"
 ```
 
 If external edits are detected: warn the user before proceeding.
@@ -148,7 +148,7 @@ Display:
 Wait for user choice via natural conversation.
 
 - **View results:** Fetch and display summary comments (`<!-- maxsim:type=summary -->`) from the phase issue, then re-show options.
-- **Re-execute:** Reopen task sub-issues via `mcp_reopen_issue` for each task sub-issue, restart from Execute Plans (step 4).
+- **Re-execute:** Reopen task sub-issues via `github reopen-issue` for each task sub-issue, restart from Execute Plans (step 4).
 - **View verification:** Fetch and display the verification comment (`<!-- maxsim:type=verification -->`) from the phase issue, then re-show options.
 - **Done:** Exit workflow.
 
@@ -235,7 +235,7 @@ Execute each wave in sequence. Within a wave: parallel if `parallelization` is t
        <success_criteria>
        - [ ] All tasks executed
        - [ ] Each task committed individually
-       - [ ] Summary posted as GitHub comment (mcp_post_comment with type=summary) on phase issue
+       - [ ] Summary posted as GitHub comment (`github post-comment` with type=summary) on phase issue
        - [ ] Task sub-issues moved: In Progress when started, Done when completed
        - [ ] STATE.md updated with position and decisions
        - [ ] ROADMAP.md updated with plan progress
@@ -290,8 +290,8 @@ Proceeding to verification...
 ```
 
 **Move phase issue to "In Review" on GitHub (WIRE-08):**
-```
-mcp_move_issue(issue_number: phase_issue_number, status: "In Review")
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github move-issue --issue-number $PHASE_ISSUE_NUMBER --status "In Review"
 ```
 This signals all tasks are complete and the phase is awaiting verification. The phase moves to "Done" only after verification passes.
 
@@ -318,7 +318,7 @@ Phase goal: {goal from ROADMAP.md}
 Phase requirement IDs: {phase_req_ids}
 Check must_haves against actual codebase.
 Cross-reference requirement IDs from plan frontmatter against REQUIREMENTS.md.
-Post verification results as a GitHub comment (mcp_post_comment with type=verification) on the phase issue.
+Post verification results as a GitHub comment (`github post-comment` with type=verification) on the phase issue.
 Also write VERIFICATION.md to the phase directory for local reference.",
   subagent_type="verifier",
   model="{verifier_model}"
@@ -329,8 +329,8 @@ Also write VERIFICATION.md to the phase directory for local reference.",
 
 Read verification status from the verification comment on the phase issue:
 
-```
-mcp_get_issue_detail(issue_number: phase_issue_number)
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github get-issue $PHASE_ISSUE_NUMBER --comments
 ```
 
 Look for the `<!-- maxsim:type=verification -->` comment and parse the `status:` field from its body.
@@ -347,17 +347,23 @@ Phase {phase_number} complete!
 ```
 
 Move phase issue to "Done" status:
-```
-mcp_move_issue(issue_number: phase_issue_number, status: "Done")
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github move-issue --issue-number $PHASE_ISSUE_NUMBER --status "Done"
 ```
 
 Post phase completion comment:
-```
-mcp_post_comment(
-  issue_number: phase_issue_number,
-  type: "phase-complete",
-  body: "## Phase {phase_number} Complete\n\nAll plans executed and verified.\n\n**Plans:** {completed}/{total}\n**Waves:** {wave_count}\n**Verification:** Passed"
-)
+```bash
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'BODY_EOF'
+## Phase {phase_number} Complete
+
+All plans executed and verified.
+
+**Plans:** {completed}/{total}
+**Waves:** {wave_count}
+**Verification:** Passed
+BODY_EOF
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $PHASE_ISSUE_NUMBER --body-file "$TMPFILE" --type phase-complete
 ```
 
 Mark phase complete:
@@ -372,12 +378,14 @@ node .claude/maxsim/bin/maxsim-tools.cjs commit "docs(phase-{X}): complete phase
 
 **If `gaps_found`:** Post a gaps comment on the phase issue, then proceed to Retry Loop (step 6).
 
-```
-mcp_post_comment(
-  issue_number: phase_issue_number,
-  type: "verification-gaps",
-  body: "## Verification Gaps Found\n\n{gap summaries from verification result}"
-)
+```bash
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'BODY_EOF'
+## Verification Gaps Found
+
+{gap summaries from verification result}
+BODY_EOF
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $PHASE_ISSUE_NUMBER --body-file "$TMPFILE" --type verification-gaps
 ```
 
 **If `human_needed`:** Present items for human testing, get approval or feedback. If approved, treat as passed. If issues reported, proceed to Retry Loop.
@@ -431,7 +439,7 @@ Task(
 <downstream_consumer>
 Output consumed by /maxsim:execute.
 Plans must be executable prompts.
-Post gap-closure plans as comments on phase issue #{phase_issue_number} using mcp_post_comment with type=plan.
+Post gap-closure plans as comments on phase issue #{phase_issue_number} using `github post-comment` with type=plan.
 </downstream_consumer>
 ",
   subagent_type="planner",
@@ -456,12 +464,19 @@ At any point during the workflow, if context is getting full (conversation is lo
 
 **Checkpoint protocol:**
 1. Post a checkpoint comment to the phase's GitHub Issue (if issue tracking is active):
-```
-mcp_post_comment(
-  issue_number: phase_issue_number,
-  type: "checkpoint",
-  body: "## MAXSIM Checkpoint\n\n**Command:** /maxsim:execute\n**Stage:** {current_stage}\n**Plans completed:** {completed_count}/{total_count}\n**Verification attempts:** {attempt_count}/3\n**Resume from:** {next_action}\n**Timestamp:** {ISO timestamp}"
-)
+```bash
+TMPFILE=$(mktemp)
+cat > "$TMPFILE" << 'BODY_EOF'
+## MAXSIM Checkpoint
+
+**Command:** /maxsim:execute
+**Stage:** {current_stage}
+**Plans completed:** {completed_count}/{total_count}
+**Verification attempts:** {attempt_count}/3
+**Resume from:** {next_action}
+**Timestamp:** {ISO timestamp}
+BODY_EOF
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github post-comment --issue-number $PHASE_ISSUE_NUMBER --body-file "$TMPFILE" --type checkpoint
 ```
 
 2. Display checkpoint recommendation:

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

@@ -42,12 +42,13 @@ Read local files for project context:
 
 **3. Live GitHub state (primary source — always-live, no cached state):**
 
-Call `mcp_get_all_progress` to get current state of all phases from GitHub. Returns:
-- `phase_number`, `title`, `issue_number`
-- `total_tasks`, `completed_tasks`, `remaining_tasks`
-- `status` (GitHub board column: To Do / In Progress / In Review / Done)
+Run `github status` to get current state of all phases and detect interrupted work in one call:
 
-Call `mcp_detect_interrupted` to check for any phases that were interrupted mid-execution (e.g., agent was stopped while a task was marked in-flight).
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github status
+```
+
+Returns: `phase_number`, `title`, `issue_number`, `total_tasks`, `completed_tasks`, `remaining_tasks`, `status` (GitHub board column: To Do / In Progress / In Review / Done), and any interrupted phase detection.
 
 **4. Git context:**
 ```bash
@@ -108,7 +109,11 @@ Resolve this before continuing. Options:
 Block until user responds.
 
 **3. Failed verification on GitHub**
-Check if any phase issue has a verification comment with FAIL status (from live GitHub data via `mcp_get_all_progress` — look for phases stuck in "In Review" with a known failure, or check recent comments via `mcp_get_issue_detail` for the current phase issue):
+Check if any phase issue has a verification comment with FAIL status (from live GitHub data via `github all-progress` — look for phases stuck in "In Review" with a known failure, or check recent comments via `github get-issue` for the current phase issue):
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github get-issue N --comments
+```
 ```
 ## Problem Detected
 
@@ -135,7 +140,7 @@ Block until user responds.
 
 Apply rules in strict precedence order. The FIRST matching rule determines the action.
 
-Use live GitHub data from `mcp_get_all_progress` and `mcp_detect_interrupted` (gathered in Phase 1) as the primary source of truth for phase state. Use local ROADMAP.md for phase ordering only.
+Use live GitHub data from `github status` (gathered in Phase 1) as the primary source of truth for phase state. Use local ROADMAP.md for phase ordering only.
 
 ```
 Rule 1: No .planning/ directory?
@@ -146,17 +151,17 @@ Rule 2: Has blockers in STATE.md? (not cleared in problem detection)
   -> Action: Surface blocker, suggest resolution
   -> Reasoning: "BLOCKED: {blocker text}"
 
-Rule 3: Interrupted phase detected (from mcp_detect_interrupted)?
+Rule 3: Interrupted phase detected (from `github status`)?
   -> Action: /maxsim:execute {N}
   -> Reasoning: "Phase {N} ({name}) was interrupted. Resuming execution."
 
 Rule 4: Phase "In Progress" on GitHub board with incomplete tasks?
-  -> Check: mcp_get_all_progress returns a phase with status="In Progress" and remaining_tasks > 0
+  -> Check: `github status` returns a phase with status="In Progress" and remaining_tasks > 0
   -> Action: /maxsim:execute {N}
   -> Reasoning: "Phase {N} ({name}) has {remaining} tasks remaining. Ready to continue."
 
 Rule 5: Phase "To Do" on GitHub board (not yet started)?
-  -> Check: mcp_get_all_progress returns the next unstarted phase (status="To Do")
+  -> Check: `github status` returns the next unstarted phase (status="To Do")
   -> Action: /maxsim:plan {N}
   -> Reasoning: "Phase {N} ({name}) needs planning."
 
@@ -165,12 +170,12 @@ Rule 5: Phase "To Do" on GitHub board (not yet started)?
   -> If no: "Starting from discussion stage."
 
 Rule 6: Current phase "In Review" on GitHub board?
-  -> Check: mcp_get_all_progress returns a phase with status="In Review"
+  -> Check: `github status` returns a phase with status="In Review"
   -> Action: /maxsim:execute {N}
   -> Reasoning: "Phase {N} ({name}) is awaiting verification."
 
 Rule 7: All phases "Done" on GitHub board?
-  -> Check: mcp_get_all_progress — all phases have status="Done"
+  -> Check: `github status` — all phases have status="Done"
   -> Action: /maxsim:progress
   -> Reasoning: "All phases complete. Milestone ready for review."
 
@@ -193,7 +198,7 @@ Once a rule matches, display detection reasoning FIRST, then act immediately.
 **Project:** {project name from PROJECT.md, or "New project"}
 **Milestone:** {milestone from ROADMAP.md, or "Not started"}
 **Current phase:** {phase N - name, or "None"} (GitHub Issue #{issue_number})
-**GitHub Status:** {board column from live mcp_get_all_progress data}
+**GitHub Status:** {board column from live `github status` data}
 **Tasks:** {completed}/{total} complete
 
 **Action:** Running /maxsim:{command} {args}...
@@ -207,7 +212,7 @@ Then immediately dispatch the command using the SlashCommand tool. The user can
 <step name="interactive_menu">
 **Phase 5: Interactive Menu (Rule 8 — no obvious action)**
 
-When no clear action is detected, show a contextual menu. The menu items are NOT static — filter based on what makes sense for the current project state (use live GitHub data from mcp_get_all_progress).
+When no clear action is detected, show a contextual menu. The menu items are NOT static — filter based on what makes sense for the current project state (use live GitHub data from `github status`).
 
 ```
 ## Project Status
@@ -233,7 +238,7 @@ Or describe what you'd like to do:
 - If no phases exist on board: show `/maxsim:plan` prominently
 - Always include `/maxsim:quick` as it is always relevant
 - Always include an open-ended fallback ("Or describe what you'd like to do")
-- If GitHub not available (mcp calls fail): note degraded mode, recommend resolving GitHub connectivity
+- If GitHub not available (CLI calls fail): show error: "GitHub integration required. Run `/maxsim:init` to configure GitHub." Do NOT fall back to local file scanning.
 
 Wait for user selection, then dispatch the chosen command.
 </step>
@@ -247,7 +252,7 @@ Wait for user selection, then dispatch the chosen command.
 - No arguments accepted — this is pure auto-detection
 - No mention of old commands (plan, execute-phase, etc.)
 - Keep initial feedback fast — show "Analyzing..." before heavy operations
-- Primary source for phase state: live GitHub (mcp_get_all_progress, mcp_detect_interrupted)
+- Primary source for phase state: live GitHub (`github status`)
 - Local reads: STATE.md for blockers/decisions, ROADMAP.md for phase ordering only
 - If context gathering fails (tools not available, etc.), fall back to the interactive menu
 </constraints>

package/dist/assets/templates/workflows/init-existing.md

@@ -108,16 +108,16 @@ Parse init context for `has_github_remote` and `gh_authenticated`:
      ```
    - Do NOT proceed with initialization.
 
-3. Both checks passed — call `mcp_github_setup` with the project name as the milestone title:
-   ```
-   mcp_github_setup({ milestone_title: "[project name]" })
+3. Both checks passed — run `github setup` with the project name as the milestone title:
+   ```bash
+   node ~/.claude/maxsim/bin/maxsim-tools.cjs github setup --milestone-title "[project name]"
    ```
 
-4. If `mcp_github_setup` fails:
+4. If `github setup` fails:
    - STOP with the error message returned by the tool.
    - Do not fall back to local-only mode.
 
-5. Record the `project_number` and board details returned by `mcp_github_setup` for use in the Phase Issue Creation step.
+5. Record the `project_number` and board details returned by `github setup` for use in the Phase Issue Creation step.
 
 ## Step 2: Conflict Resolution
 
@@ -1174,15 +1174,12 @@ Display banner:
    - `requirements` (list of REQ-IDs mapped to this phase)
    - `success_criteria` (list of observable outcomes)
 
-2. For each phase, call `mcp_create_phase_issue`:
-   ```
-   mcp_create_phase_issue({
-     phase_number: "[phase_number]",
-     phase_name: "[phase_name]",
-     goal: "[goal]",
-     requirements: ["REQ-01", "REQ-02", ...],
-     success_criteria: ["criterion 1", "criterion 2", ...]
-   })
+2. For each phase, run `github create-phase`:
+   ```bash
+   node ~/.claude/maxsim/bin/maxsim-tools.cjs github create-phase \
+     --phase-number "[phase_number]" \
+     --phase-name "[phase_name]" \
+     --goal "[goal]"
    ```
    The tool auto-adds each issue to the project board with "To Do" status.
 
@@ -1457,7 +1454,7 @@ Print next steps:
 - [ ] Git repo initialized (if not already)
 - [ ] GitHub remote detected (gate passed)
 - [ ] GitHub CLI authenticated (gate passed)
-- [ ] `mcp_github_setup` called successfully — project_number recorded
+- [ ] `github setup` called successfully — project_number recorded
 - [ ] Conflict detection completed (merge/overwrite/cancel dialog)
 - [ ] Codebase scan completed (4 mapper agents spawned)
 - [ ] README validated against scan findings
@@ -1469,7 +1466,7 @@ Print next steps:
 - [ ] PROJECT.md created with brownfield extra sections
 - [ ] REQUIREMENTS.md created with stage-aware format
 - [ ] ROADMAP.md created with 3-5 concrete phases (no TBD)
-- [ ] `mcp_create_phase_issue` called for every phase — all issues on board with "To Do" status
+- [ ] `github create-phase` called for every phase — all issues on board with "To Do" status
 - [ ] STATE.md created with pre-populated decisions and blockers
 - [ ] config.json created with workflow settings
 - [ ] .planning/codebase/ populated with scan documents

package/dist/assets/templates/workflows/new-milestone.md

@@ -333,6 +333,26 @@ Success criteria:
 node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "docs: create milestone v[X.Y] roadmap ([N] phases)" --files .planning/ROADMAP.md .planning/STATE.md .planning/REQUIREMENTS.md
 ```
 
+## 10b. Create Phase Tracking Issues on GitHub
+
+**This step is MANDATORY — GitHub Issues are the single source of truth for phase tracking.**
+
+For each phase in the roadmap, run `github create-phase` to create a tracking issue:
+
+```bash
+# For each phase:
+node ~/.claude/maxsim/bin/maxsim-tools.cjs github create-phase \
+  --phase-number "[N]" \
+  --phase-name "[Phase Name]" \
+  --goal "[Phase Goal from ROADMAP.md]"
+```
+
+Track results. If any phase issue creation fails, warn and suggest manual creation.
+
+```
+✓ Created {N} phase issues on GitHub Project Board
+```
+
 ## 11. Done
 
 ```
@@ -348,8 +368,9 @@ node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "docs: create milestone v[X.Y]
 | Research       | `.planning/research/`       |
 | Requirements   | `.planning/REQUIREMENTS.md` |
 | Roadmap        | `.planning/ROADMAP.md`      |
+| Phase Issues   | GitHub Project Board        |
 
-**[N] phases** | **[X] requirements** | Ready to build ✓
+**[N] phases** | **[X] requirements** | **[N] GitHub issues** | Ready to build ✓
 
 ## ▶ Next Up
 
@@ -375,6 +396,7 @@ Also: `/maxsim:plan [N]` — skip discussion, plan directly
 - [ ] Roadmap files written immediately (not draft)
 - [ ] User feedback incorporated (if any)
 - [ ] ROADMAP.md phases continue from previous milestone
+- [ ] `github create-phase` called for every phase — all issues on GitHub board
 - [ ] All commits made (if planning docs committed)
 - [ ] User knows next step: `/maxsim:plan [N]`