mindsystem-cc 3.19.0 → 3.21.0

package/commands/ms/new-milestone.md

@@ -1,7 +1,7 @@
 ---
 name: ms:new-milestone
 description: Start a new milestone — discover what to build, update PROJECT.md, create context for downstream
-argument-hint: "[milestone name, e.g., 'v1.1 Notifications']"
+argument-hint: "[name, e.g., 'Notifications']"
 allowed-tools:
   - Read
   - Write
@@ -39,12 +39,36 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
 
 ## Phase 1: Orient
 
+0. **Validate PROJECT.md exists:**
+
+   ```bash
+   [ -f .planning/PROJECT.md ] || { echo "NO_PROJECT"; exit 0; }
+   ```
+
+   **If `NO_PROJECT`:** Present message and stop:
+
+   ```
+   No PROJECT.md found. Initialize the project first to capture business context, target audience, and project vision.
+
+   ---
+
+   ## ▶ Next Up
+
+   `/ms:new-project` — Initialize project with business context and vision
+
+   <sub>`/clear` first → fresh context window</sub>
+
+   ---
+   ```
+
+   **You MUST run the bash command above using the Bash tool before proceeding.**
+
 1. **Load context:**
    - Read PROJECT.md (existing project, validated requirements, decisions)
    - Read MILESTONES.md (what shipped previously)
    - Read STATE.md (pending todos, blockers)
    - Read config.json (project settings)
-   - Calculate previous milestone version from MILESTONES.md (e.g., if last shipped was v1.0, previous=1.0)
+   - Identify previous milestone name from MILESTONES.md (e.g., last shipped was "MVP")
 
 2. **Check for active milestone:**
 
@@ -52,7 +76,7 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
 
    Use AskUserQuestion:
    - header: "Active milestone"
-   - question: "There's a milestone in progress (v[X.Y]). What do you want to do?"
+   - question: "There's a milestone in progress ([Name]). What do you want to do?"
    - options:
      - "Complete it first" — run /ms:complete-milestone
      - "Add phases to it" — run /ms:add-phase
@@ -62,9 +86,9 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
    If "Continue anyway": proceed.
 
 3. **Strategic assessment (silent — do not output this step):**
-   - Check for previous milestone artifacts using calculated version:
+   - Check for previous milestone artifacts:
      - `.planning/knowledge/*.md` (subsystem knowledge files — persist across milestones)
-     - `.planning/milestones/v{VERSION}/MILESTONE-AUDIT.md` (if exists)
+     - `.planning/milestones/{slug}/MILESTONE-AUDIT.md` (if exists, for last completed milestone)
      - `.planning/TECH-DEBT.md` (if exists)
    - Identify: outstanding tech debt, untested assumptions, high-impact gaps, unaddressed requirements
    - This is background analysis — synthesize silently, surface through suggestions in step 4
@@ -74,7 +98,7 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
    ```
    ## Last Milestone
 
-   v[X.Y] [Name] — [key accomplishments, 1-2 lines]
+   [Name] — [key accomplishments, 1-2 lines]
 
    ## Suggested Directions
 
@@ -88,10 +112,10 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
    - Settled decisions and patterns from knowledge files
    - Untested assumptions from previous audit
    - Unaddressed requirements from previous milestones
-   - Strategic features inferred from PROJECT.md's problem/audience/USP
+   - Strategic features inferred from PROJECT.md: Who It's For, Core Problem, How It's Different
    - Pending todos from STATE.md
 
-   If no meaningful artifacts exist (first milestone after v1.0), base suggestions purely on PROJECT.md.
+   If no meaningful artifacts exist (first milestone), base suggestions purely on PROJECT.md.
 
 5. **Freeform opening:**
 
@@ -157,17 +181,17 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
 
 ## Phase 3: Commit
 
-12. **Determine milestone version:**
-    - Parse last version from MILESTONES.md
-    - Suggest next version (v1.0 → v1.1, or v2.0 for major shifts)
-    - Confirm with user via AskUserQuestion
+12. **Determine milestone name:**
+    - Derive milestone name from the conversation (e.g., "Push Notifications", "Security Hardening")
+    - Generate slug from name (e.g., "push-notifications", "security-hardening")
+    - Confirm name with user via AskUserQuestion
 
 13. **Present milestone summary:**
 
     ```
     ## Milestone Summary
 
-    **Version:** v[X.Y] [Name]
+    **Name:** [Name]
     **Goal:** [One sentence]
     **Target features:**
     - [Feature 1]
@@ -189,7 +213,7 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
     Add/update these sections:
 
     ```markdown
-    ## Current Milestone: v[X.Y] [Name]
+    ## Current Milestone: [Name]
 
     **Goal:** [One sentence describing milestone focus]
 
@@ -199,8 +223,8 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
     - [Feature 3]
     ```
 
-    Update Active requirements section with new goals.
     Update "Last updated" footer.
+    Note: Milestone-specific goals live in MILESTONE-CONTEXT.md (step 15), not in PROJECT.md.
 
 15. **Write MILESTONE-CONTEXT.md:**
 
@@ -222,7 +246,7 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
     Phase: Not started (run /ms:create-roadmap)
     Plan: —
     Status: Defining requirements
-    Last activity: [today] — Milestone v[X.Y] started
+    Last activity: [today] — Milestone [Name] started
 
     Progress: ░░░░░░░░░░ 0%
     ```
@@ -234,7 +258,7 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
     ```bash
     git add .planning/PROJECT.md .planning/STATE.md .planning/MILESTONE-CONTEXT.md
     git commit -m "$(cat <<'EOF'
-    docs: start milestone v[X.Y] [Name]
+    docs: start milestone [Name]
     EOF
     )"
     ```
@@ -256,7 +280,7 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
     Based on the conversation, recommend ONE path. If unfamiliar domains or open questions surfaced during discovery, recommend `/ms:research-project`. Otherwise recommend `/ms:create-roadmap`.
 
     ```
-    Milestone v[X.Y] [Name] initialized.
+    Milestone [Name] initialized.
 
     PROJECT.md updated with new goals.
     Context saved to MILESTONE-CONTEXT.md
@@ -285,7 +309,6 @@ Milestone name: $ARGUMENTS (optional — will emerge during discovery if not pro
 
 <success_criteria>
 - PROJECT.md updated with Current Milestone section
-- Active requirements reflect new milestone goals
 - MILESTONE-CONTEXT.md created with vision, features, scope, priorities
 - STATE.md reset for new milestone
 - Git commit made

package/commands/ms/new-project.md

@@ -12,7 +12,7 @@ allowed-tools:
 
 Initialize a new project through comprehensive context gathering.
 
-This is the most leveraged moment in any project. Deep questioning here means better plans, better execution, better outcomes. The quality of PROJECT.md determines the quality of everything downstream.
+Questioning depth determines PROJECT.md quality, which determines everything downstream. Invest disproportionate effort here — the other steps are mechanical.
 
 Creates `.planning/` with PROJECT.md and config.json.
 
@@ -31,11 +31,11 @@ Creates `.planning/` with PROJECT.md and config.json.
 
 <step name="setup">
 
-**MANDATORY FIRST STEP — Execute these checks before ANY user interaction:**
+**Run before any user interaction:**
 
-1. **Abort if project exists:**
+1. **Detect update mode:**
    ```bash
-   [ -f .planning/PROJECT.md ] && echo "ERROR: Project already initialized. Use /ms:progress" && exit 1
+   [ -f .planning/PROJECT.md ] && echo "IS_UPDATE=true" || echo "IS_UPDATE=false"
    ```
 
 2. **Initialize git repo in THIS directory** (required even if inside a parent repo):
@@ -54,85 +54,69 @@ Creates `.planning/` with PROJECT.md and config.json.
    # Check for existing code files
    CODE_FILES=$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" -o -name "*.java" 2>/dev/null | grep -v node_modules | grep -v .git | head -20)
    HAS_PACKAGE=$([ -f package.json ] || [ -f requirements.txt ] || [ -f Cargo.toml ] || [ -f go.mod ] || [ -f Package.swift ] && echo "yes")
+   IS_BROWNFIELD=$( ([ -n "$CODE_FILES" ] || [ "$HAS_PACKAGE" = "yes" ]) && echo "yes" || echo "no")
    HAS_CODEBASE_MAP=$([ -d .planning/codebase ] && echo "yes")
    ```
 
-   **You MUST run all bash commands above using the Bash tool before proceeding.**
+   **Run all commands above before proceeding.**
 
 </step>
 
-<step name="brownfield_offer">
+<step name="question">
 
-**If existing code detected and .planning/codebase/ doesn't exist:**
+**Open the conversation:**
 
-Check the results from setup step:
-- If `CODE_FILES` is non-empty OR `HAS_PACKAGE` is "yes"
-- AND `HAS_CODEBASE_MAP` is NOT "yes"
+**If IS_UPDATE=true (update mode):**
+- Read existing `.planning/PROJECT.md`
+- Present a brief summary of the current project context
+- Ask inline (freeform, NOT AskUserQuestion): "What do you want to update?"
+- Follow the same questioning principles below, but focused on what changed
 
-Use AskUserQuestion:
-- header: "Existing Code"
-- question: "I detected existing code in this directory. Would you like to map the codebase first?"
-- options:
-  - "Map codebase first" — Run /ms:map-codebase to understand existing architecture (Recommended)
-  - "Skip mapping" — Proceed with project initialization
+**If IS_UPDATE=false (first run):**
 
-**If "Map codebase first":**
-```
-Run `/ms:map-codebase` first, then return to `/ms:new-project`
-```
-Exit command.
-
-**If "Skip mapping":** Continue to question step.
+Ask inline (freeform, NOT AskUserQuestion):
 
-**If no existing code detected OR codebase already mapped:** Continue to question step.
+- **Greenfield** (no existing code): "What do you want to build?"
+- **Brownfield** (code detected in Step 1): "Tell me about this project — if you were explaining it to someone who's never seen it, what does it do and who uses it?"
 
-</step>
+For brownfield, explicitly note: "Not the next feature — the product as a whole."
 
-<step name="question">
+Wait for their response. This gives you the context needed to ask intelligent follow-up questions.
 
-**Open the conversation:**
+**Derive business context:**
 
-Ask inline (freeform, NOT AskUserQuestion):
+After the initial response, infer business context before asking more questions. Present inferred audience/problem/differentiation for the user to react to:
 
-"What do you want to build?"
+"It sounds like this is for [audience] dealing with [problem], and your approach is different because [differentiation]. Sound right?"
 
-Wait for their response. This gives you the context needed to ask intelligent follow-up questions.
+This leverages what they've already said and gives them something concrete to react to.
 
 **Follow the thread:**
 
 Based on what they said, ask follow-up questions that dig into their response. Use AskUserQuestion with options that probe what they mentioned — interpretations, clarifications, concrete examples.
 
-Keep following threads. Each answer opens new threads to explore. Ask about:
-- What excited them
-- What problem sparked this
-- What they mean by vague terms
-- What it would actually look like
-- What's already decided
+Track coverage against the 6-item context checklist from `questioning.md`. Probe fuzziest areas first — spend questioning budget where clarity is lowest.
 
-Consult `questioning.md` for techniques:
-- Challenge vagueness
-- Make abstract concrete
-- Surface assumptions
-- Find edges
-- Reveal motivation
+Use grounding questions from `questioning.md` instead of template-shaped questions. Don't ask "Who is your target audience?" — ask "Who would be your first 10 users?"
 
-**Check context (background, not out loud):**
+When the conversation pauses and sections are still fuzzy, use success-backward: "Imagine this is wildly successful in a year. What does that look like?"
 
-As you go, mentally check the context checklist from `questioning.md`. If gaps remain, weave questions naturally. Don't suddenly switch to checklist mode.
+Consult `questioning.md` for techniques — challenge vagueness, derive before asking.
 
 **Decision gate:**
 
 When you could write a clear PROJECT.md, use AskUserQuestion:
 
 - header: "Ready?"
-- question: "I think I understand what you're after. Ready to create PROJECT.md?"
+- question (first run): "I think I understand what you're after. Ready to create PROJECT.md?"
+- question (update mode): "Ready to update PROJECT.md with these changes?"
 - options:
-  - "Create PROJECT.md" — Let's move forward
+  - "Create PROJECT.md" / "Update PROJECT.md" — Let's move forward
   - "Keep exploring" — I want to share more / ask me more
 
 If "Keep exploring" — ask what they want to add, or identify gaps and probe naturally.
 
-Loop until "Create PROJECT.md" selected.
+Loop until create/update selected.
 
 </step>
 
@@ -142,54 +126,31 @@ Synthesize all context into `.planning/PROJECT.md` using the template from `temp
 
 **For greenfield projects:**
 
-Initialize requirements as hypotheses:
-
-```markdown
-## Requirements
-
-### Validated
-
-(None yet — ship to validate)
-
-### Active
-
-- [ ] [Requirement 1]
-- [ ] [Requirement 2]
-- [ ] [Requirement 3]
-
-### Out of Scope
-
-- [Exclusion 1] — [why]
-- [Exclusion 2] — [why]
-```
-
-All Active requirements are hypotheses until shipped and validated.
+Initialize all sections from questioning:
+- **What This Is** — product identity from questioning
+- **Core Value** — the ONE thing from questioning
+- **Who It's For** — target audience from questioning
+- **Core Problem** — pain or desire from questioning
+- **How It's Different** — differentiators from questioning
+- **Key User Flows** — core interactions from questioning
+- **Out of Scope** — boundaries from questioning
+- **Constraints** — hard limits from questioning
+- **Technical Context** — minimal for greenfield (stack choices if discussed)
+- **Validated** — `(None yet — ship to validate)`
+- **Key Decisions** — any decisions made during questioning
 
 **For brownfield projects (codebase map exists):**
 
-Infer Validated requirements from existing code:
+Same as greenfield, plus:
 
 1. Read `.planning/codebase/ARCHITECTURE.md` and `STACK.md`
-2. Identify what the codebase already does
-3. These become the initial Validated set
+2. Infer Validated requirements from existing code — what the codebase already does
+3. Populate Technical Context from codebase map (stack, integrations, known debt)
 
 ```markdown
-## Requirements
-
-### Validated
-
+## Validated
 - ✓ [Existing capability 1] — existing
 - ✓ [Existing capability 2] — existing
-- ✓ [Existing capability 3] — existing
-
-### Active
-
-- [ ] [New requirement 1]
-- [ ] [New requirement 2]
-
-### Out of Scope
-
-- [Exclusion 1] — [why]
 ```
 
 **Key Decisions:**
@@ -217,7 +178,7 @@ Do not compress. Capture everything gathered.
 
 <step name="config">
 
-Create `.planning/config.json` with subsystems and code_review using `templates/config.json` structure.
+Create or update `.planning/config.json` with subsystems and code_review using `templates/config.json` structure.
 
 **Subsystems:** Derive 5-10 initial subsystems from the project context gathered during questioning. These are short, lowercase identifiers for the major functional areas of the project.
 
@@ -228,10 +189,13 @@ Examples by project type:
 
 These values are used throughout the system for consistent categorization of summaries, debug docs, and adhoc work.
 
+**Update mode (config.json already exists):** Re-derive subsystems from updated context. Preserve any existing `code_review` values — do not overwrite configured reviewers with nulls.
+
 </step>
 
 <step name="commit">
 
+**First run:**
 ```bash
 git add .planning/PROJECT.md .planning/config.json
 git commit -m "$(cat <<'EOF'
@@ -239,7 +203,18 @@ docs: initialize [project-name]
 
 [One-liner from PROJECT.md]
 
-Creates PROJECT.md with requirements and constraints.
+Creates PROJECT.md with business context and constraints.
+EOF
+)"
+```
+
+**Update mode:**
+```bash
+git add .planning/PROJECT.md .planning/config.json
+git commit -m "$(cat <<'EOF'
+docs: update [project-name] project context
+
+[Brief description of what changed]
 EOF
 )"
 ```
@@ -250,31 +225,40 @@ EOF
 
 Present completion with next steps (see ~/.claude/mindsystem/references/continuation-format.md):
 
+**First run:**
 ```
 Project initialized:
 
 - Project: .planning/PROJECT.md
 - Config: .planning/config.json
 [If .planning/codebase/ exists:] - Codebase: .planning/codebase/ (7 documents)
+```
 
----
-
-## ▶ Next Up
+**Update mode:**
+```
+Project updated:
 
-Choose your path:
+- Project: .planning/PROJECT.md
+- Config: .planning/config.json
+```
 
-**Option A: Research first** (recommended)
-Research ecosystem → define requirements → create roadmap. Discovers standard stacks, expected features, architecture patterns.
+**Routing (both modes):**
 
-`/ms:research-project`
+```
+---
 
-**Option B: Define requirements and roadmap directly** (familiar domains)
-Skip research, define requirements and create roadmap from what you know.
+## ▶ Next Up
 
-`/ms:create-roadmap`
+`/ms:new-milestone` — Discover what to build first, create requirements and roadmap
 
 <sub>`/clear` first → fresh context window</sub>
 
+---
+
+**Also available:**
+- `/ms:config` — Configure code reviewers, gitignore, and other preferences
+[If brownfield detected and no codebase map:] - `/ms:map-codebase` — Analyze existing codebase for technical context
+
 ---
 ```
 
@@ -299,11 +283,12 @@ Update `.planning/STATE.md` Last Command field (if STATE.md exists):
 
 <success_criteria>
 
-- [ ] Deep questioning completed (not rushed, threads followed)
-- [ ] PROJECT.md captures full context with evolutionary structure
-- [ ] Requirements initialized as hypotheses (greenfield) or with inferred Validated (brownfield)
-- [ ] Key Decisions table initialized
-- [ ] config.json has subsystems and code_review settings
 - [ ] All committed to git
+- [ ] config.json has subsystems and code_review settings (existing code_review preserved in update mode)
+- [ ] Validated requirements initialized (empty for greenfield, inferred for brownfield)
+- [ ] Deep questioning completed with business context extracted (or update conversation completed)
+- [ ] PROJECT.md captures product identity (What/Value/Audience/Problem/Differentiation/Flows)
+- [ ] PROJECT.md captures boundaries (Out of Scope, Constraints, Technical Context)
+- [ ] Key Decisions table initialized
 
 </success_criteria>

package/commands/ms/plan-milestone-gaps.md

@@ -25,7 +25,7 @@ One command creates all fix phases — no manual `/ms:add-phase` per gap.
 
 <context>
 **Audit results:**
-Glob: .planning/v*-MILESTONE-AUDIT.md (use most recent)
+@.planning/MILESTONE-AUDIT.md
 
 **Original intent (for prioritization):**
 @.planning/PROJECT.md
@@ -41,8 +41,7 @@ Glob: .planning/v*-MILESTONE-AUDIT.md (use most recent)
 ## 1. Load Audit Results
 
 ```bash
-# Find the most recent audit file
-ls -t .planning/v*-MILESTONE-AUDIT.md 2>/dev/null | head -1
+cat .planning/MILESTONE-AUDIT.md
 ```
 
 Parse YAML frontmatter to extract structured gaps:
@@ -105,7 +104,7 @@ New phases continue from there:
 ```markdown
 ## Gap Closure Plan
 
-**Milestone:** {version}
+**Milestone:** {name}
 **Gaps to close:** {N} requirements, {M} integration, {K} flows
 
 ### Proposed Phases
@@ -191,7 +190,7 @@ git commit -m "docs(roadmap): add gap closure phases {N}-{M}"
 **After all gap phases complete:**
 
 `/ms:audit-milestone` — re-audit to verify gaps closed
-`/ms:complete-milestone {version}` — archive when audit passes
+`/ms:complete-milestone` — archive when audit passes
 ```
 
 ## 10. Update Last Command

package/commands/ms/plan-phase.md

@@ -12,6 +12,7 @@ allowed-tools:
   - WebFetch
   - mcp__context7__*
   - Task
+  - Skill
 ---
 
 <objective>
@@ -33,11 +34,11 @@ When invoked with `--gaps`, plans address gaps identified by the verifier. Load
 Phase number: $ARGUMENTS (optional - auto-detects next unplanned phase if not provided)
 Gap closure mode: `--gaps` flag triggers gap closure workflow
 
-**Normalize phase number if provided:**
+**Resolve phase if provided:**
 ```bash
 PHASE_ARG=$(echo "$ARGUMENTS" | grep -oE '^[0-9]+' | head -1)
 if [ -n "$PHASE_ARG" ]; then
-  PHASE=$(printf "%02d" "$PHASE_ARG" 2>/dev/null || echo "$PHASE_ARG")
+  ms-tools find-phase "$PHASE_ARG"
 fi
 ```
 
@@ -91,7 +92,8 @@ Check for `.planning/codebase/` and load relevant documents based on phase type.
    - Scan project history via context scanner script (prior decisions, issues, debug resolutions, adhoc learnings, cross-milestone patterns)
    - Break phase into tasks
    - Propose plan grouping (plan boundaries, wave structure, budget estimates) for user review
-   - Hand off tasks + proposed grouping to plan-writer subagent
+   - Discover relevant project skills, confirm with user
+   - Hand off tasks + proposed grouping + confirmed skills to plan-writer subagent
    - Create PLAN.md file(s) with executable structure
 
 **Gap closure mode (--gaps flag):**

package/commands/ms/progress.md

@@ -129,9 +129,7 @@ DESIGN: [✓ if DESIGN.md exists | - if not]
 List files in the current phase directory:
 
 ```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
-ls -1 .planning/phases/[current-phase-dir]/*-UAT.md 2>/dev/null | wc -l
+ms-tools list-artifacts [current-phase-number]
 ```
 
 State: "This phase has {X} plans, {Y} summaries."
@@ -220,7 +218,7 @@ Check if `{phase}-CONTEXT.md` exists in phase directory.
 - `/ms:discuss-phase {phase}` — gather context first
 - `/ms:design-phase {phase}` — create UI/UX specifications
 - `/ms:research-phase {phase}` — investigate unknowns
-- `/ms:list-phase-assumptions {phase}` — see Claude's assumptions
+- `/ms:discuss-phase {phase}` — gather context and validate assumptions
 
 ---
 ```

package/commands/ms/research-phase.md

@@ -19,15 +19,14 @@ Research how to implement a phase by spawning 3 parallel specialized agents, the
 <context>
 Phase number: $ARGUMENTS (required)
 
-**Normalize phase number first:**
+**Resolve phase:**
 ```bash
-PHASE_ARG="$ARGUMENTS"
-PHASE=$(printf "%02d" "$PHASE_ARG" 2>/dev/null || echo "$PHASE_ARG")
+ms-tools find-phase "$ARGUMENTS"
 ```
 
 Check for existing research:
 ```bash
-ls .planning/phases/${PHASE}-*/*RESEARCH.md 2>/dev/null
+ms-tools check-artifact "$ARGUMENTS" RESEARCH
 ```
 </context>
 
@@ -35,11 +34,7 @@ ls .planning/phases/${PHASE}-*/*RESEARCH.md 2>/dev/null
 
 ## 1. Parse and Validate Phase
 
-```bash
-grep -A5 "Phase ${PHASE}:" .planning/ROADMAP.md 2>/dev/null
-```
-
-**If not found:** Error and exit. **If found:** Extract phase number, name, description.
+Use `find-phase` output from context. **If phase not found (dir is null):** Error and exit. **If found:** Extract phase number, name, description from ROADMAP.md.
 
 ## 2. Check Existing Research
 
@@ -128,8 +123,8 @@ Phase Research — External Documentation focus.
 <focus>
 Library documentation, APIs, version-specific behavior, verified code examples.
 Use the ms-lookup CLI for library docs and deep research:
-  ~/.claude/mindsystem/scripts/ms-lookup-wrapper.sh docs <library> '<query>'
-  ~/.claude/mindsystem/scripts/ms-lookup-wrapper.sh deep '<query>'
+  ms-lookup docs <library> '<query>'
+  ms-lookup deep '<query>'
 Use WebSearch for ecosystem discovery.
 Focus on finding authoritative, current documentation for the libraries and tools
 needed to implement this phase.
@@ -230,7 +225,7 @@ Phase Research — Best Practices & Community Consensus focus.
 <focus>
 Community consensus, common pitfalls, proven approaches, state of the art.
 Use the ms-lookup CLI for deep research on high-value questions:
-  ~/.claude/mindsystem/scripts/ms-lookup-wrapper.sh deep '<query>'
+  ms-lookup deep '<query>'
 Use WebSearch for community articles, blog posts, Stack Overflow patterns.
 Focus on what practitioners recommend and what mistakes to avoid.
 </focus>