maxsimcli 4.15.4 → 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,31 +37,19 @@ 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.
 
-**Fallback -- no GitHub context:**
+**If no GitHub context is available:**
 
-If no `phase_issue_number` or `plan_comment_body` was passed:
+GitHub Issues is the source of truth for plans. If no `phase_issue_number` or `plan_comment_body` was passed, report the error and exit:
 
-```bash
-# Use plans/summaries from INIT JSON, or list files
-ls .planning/phases/XX-name/*-PLAN.md 2>/dev/null | sort
-ls .planning/phases/XX-name/*-SUMMARY.md 2>/dev/null | sort
 ```
-
-Find first PLAN without matching SUMMARY. Decimal phases supported (`01.1-hotfix/`).
-
-<if mode="yolo">
-Auto-approve: `⚡ Execute {phase}-{plan}-PLAN.md [Plan X of Y for Phase Z]` → parse_segments.
-</if>
-
-<if mode="interactive" OR="custom with gates.execute_next_plan true">
-Present plan identification, wait for confirmation.
-</if>
+Plan content must be provided via GitHub Issue comment. Ensure GitHub integration is configured.
+```
 </step>
 
 <step name="record_start_time">
@@ -132,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
@@ -144,12 +124,7 @@ Pattern B only (verify-only checkpoints). Skip for A/C.
 
 The plan content IS the execution instructions. Follow exactly. If plan references CONTEXT.md: honor user's vision throughout.
 
-When plan was loaded from a GitHub comment (github_context passed): the plan content is already in memory from the load_plan_from_github step.
-
-When plan is loaded from a local file (fallback):
-```bash
-cat .planning/phases/XX-name/{phase}-{plan}-PLAN.md
-```
+The plan content is already in memory from the load_plan_from_github step (loaded from the GitHub Issue comment passed by the orchestrator).
 </step>
 
 <step name="pre_execution_gates">
@@ -193,7 +168,7 @@ fi
 node ~/.claude/maxsim/bin/maxsim-tools.cjs phases list --type summaries --raw
 # Extract the second-to-last summary from the JSON result
 ```
-If previous phase has unresolved issues (check summary comments on phase issue or local SUMMARY.md "Issues Encountered" / "Next Phase Readiness" blockers): AskUserQuestion(header="Previous Issues", options: "Proceed anyway" | "Address first" | "Review previous").
+If previous phase has unresolved issues (check summary comments on phase issue for "Issues Encountered" / "Next Phase Readiness" blockers): AskUserQuestion(header="Previous Issues", options: "Proceed anyway" | "Address first" | "Review previous").
 </step>
 
 <step name="execute">
@@ -205,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.
@@ -214,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
@@ -379,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>
 
@@ -411,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>
 
@@ -439,17 +422,15 @@ 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.
 
-**Fallback (no GitHub integration):** Write `{phase}-{plan}-SUMMARY.md` to `.planning/phases/XX-name/` as before.
+GitHub Issues is the source of truth -- summaries are always posted as GitHub comments.
 </step>
 
 <step name="review_cycle">
@@ -614,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"
 ```
 
 ---
@@ -903,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:
@@ -1020,25 +1005,37 @@ 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
 ```
 
-**Fallback (no GitHub integration):** Write VERIFICATION.md and UAT.md to the phase directory as before.
+GitHub Issues is the source of truth -- verification and UAT results are always posted as GitHub comments.
 </step>
 
 <step name="update_codebase_map">
@@ -1060,18 +1057,12 @@ 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.
 
-Fallback (no GitHub):
-```bash
-ls -1 .planning/phases/[current-phase-dir]/*-PLAN.md 2>/dev/null | wc -l
-ls -1 .planning/phases/[current-phase-dir]/*-SUMMARY.md 2>/dev/null | wc -l
-```
-
 | Condition | Route | Action |
 |-----------|-------|--------|
 | open task sub-issues remain | **A: More plans** | Find next incomplete plan (by open sub-issues or missing summary comment). Yolo: auto-continue. Interactive: show next plan, suggest `/maxsim:execute {phase}`. STOP here. |

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.
@@ -87,17 +87,20 @@ When GitHub integration is active (`phase_issue_number` is set):
    - `plan_count`: total plan comments found
    - `incomplete_count`: count of incomplete plans
 
-When GitHub integration is NOT active (no `phase_issue_number`), fall back to local file scanning:
-```bash
-PLAN_INDEX=$(node .claude/maxsim/bin/maxsim-tools.cjs phase-plan-index "${PHASE_NUMBER}")
+When GitHub integration is NOT active (no `phase_issue_number`):
 ```
+No plans found for Phase {phase_number}. GitHub Issues is the source of truth for plans.
+
+Ensure GitHub integration is configured: run /maxsim:init to set up GitHub Issues.
+```
+Exit workflow.
 
 ### 2b. Check for External Edits (WIRE-06)
 
 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.
@@ -145,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.
 
@@ -232,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
@@ -287,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.
 
@@ -315,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}"
@@ -326,17 +329,12 @@ 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.
 
-Also fall back to reading locally:
-```bash
-grep "^status:" "$PHASE_DIR"/*-VERIFICATION.md | cut -d: -f2 | tr -d ' '
-```
-
 **If `passed`:** Show verification gate and proceed to completion.
 
 ```
@@ -349,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:
@@ -374,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.
@@ -433,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",
@@ -458,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:
@@ -510,7 +523,7 @@ Display final results:
 
 <success_criteria>
 - [ ] Phase validated against roadmap
-- [ ] Plan inventory loaded from GitHub issue comments (falling back to local files if no GitHub integration)
+- [ ] Plan inventory loaded from GitHub issue comments (GitHub Issues is the source of truth)
 - [ ] External edit detection warns user if phase issue was modified externally
 - [ ] Current state correctly detected from task sub-issue closure and summary comments
 - [ ] Re-entry flow works for already-executed phases

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,31 +151,31 @@ 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."
 
-  Sub-check: Does local CONTEXT.md exist?
+  Sub-check: Does a context comment exist on the phase GitHub Issue?
   -> If yes: "Discussion complete, ready for research + planning."
   -> 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): fall back to local ROADMAP analysis and note degraded mode
+- 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>