learnship 1.9.20 → 1.9.22

package/learnship/workflows/execute-plan.md

@@ -13,6 +13,7 @@ Execute a single PLAN.md file in isolation. Useful when one plan in a phase fail
 Find the phase directory:
 ```bash
 ls .planning/phases/ | grep -E "^0*[phase]-" | head -1
+# PowerShell: Get-ChildItem .planning/phases/ | Where-Object { $_.Name -match "^0*[phase]-" } | Select-Object -First 1 -ExpandProperty Name
 PHASE_DIR=".planning/phases/[matched]"
 ```
 

package/learnship/workflows/health.md

@@ -15,7 +15,7 @@ Check if `--repair` flag is present.
 ## Step 2: Check Project Exists
 
 ```bash
-python3 -c "import os; print('OK' if os.path.isdir('.planning') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning') ? 'OK' : 'MISSING')"
 ```
 
 If `.planning/` doesn't exist:
@@ -32,40 +32,49 @@ Run the following checks and classify each as error, warning, or info:
 
 ### Required Files
 ```bash
-python3 -c "import os; print('E002: PROJECT.md not found') if not os.path.exists('.planning/PROJECT.md') else None"
-python3 -c "import os; print('E003: ROADMAP.md not found') if not os.path.exists('.planning/ROADMAP.md') else None"
-python3 -c "import os; print('E004: STATE.md not found (repairable)') if not os.path.exists('.planning/STATE.md') else None"
-python3 -c "import os; print('W003: config.json not found (repairable)') if not os.path.exists('.planning/config.json') else None"
+node -e "const fs=require('fs'); if(!fs.existsSync('.planning/PROJECT.md')) console.log('E002: PROJECT.md not found')"
+node -e "const fs=require('fs'); if(!fs.existsSync('.planning/ROADMAP.md')) console.log('E003: ROADMAP.md not found')"
+node -e "const fs=require('fs'); if(!fs.existsSync('.planning/STATE.md')) console.log('E004: STATE.md not found (repairable)')"
+node -e "const fs=require('fs'); if(!fs.existsSync('.planning/config.json')) console.log('W003: config.json not found (repairable)')"
 ```
 
 ### Config Validity
 ```bash
-cat .planning/config.json | python3 -c "import sys,json; json.load(sys.stdin)" 2>&1 || echo "E005: config.json parse error (repairable)"
+node -e "try{JSON.parse(require('fs').readFileSync('.planning/config.json','utf8'))}catch(e){console.log('E005: config.json parse error (repairable)')}"
 ```
 
 ### State / Roadmap Consistency
 ```bash
-# Check if STATE.md references a phase that exists in ROADMAP.md
-CURRENT_PHASE=$(grep -E "^Phase:" .planning/STATE.md 2>/dev/null | head -1 | grep -oE "[0-9]+")
-if [ -n "$CURRENT_PHASE" ]; then
-  grep -q "Phase ${CURRENT_PHASE}:" .planning/ROADMAP.md || echo "W002: STATE.md references phase ${CURRENT_PHASE} not found in roadmap (repairable)"
-fi
+node -e "
+const fs=require('fs');
+if(!fs.existsSync('.planning/STATE.md')||!fs.existsSync('.planning/ROADMAP.md'))process.exit(0);
+const state=fs.readFileSync('.planning/STATE.md','utf8');
+const m=state.match(/^Phase:\s*(\d+)/m);
+if(m){
+  const roadmap=fs.readFileSync('.planning/ROADMAP.md','utf8');
+  if(!roadmap.includes('Phase '+m[1]+':'))console.log('W002: STATE.md references phase '+m[1]+' not found in roadmap (repairable)');
+}
+"
 ```
 
 ### Phase Directory Checks
 ```bash
-# Phases in ROADMAP but no directory
-grep -oE "Phase [0-9]+:" .planning/ROADMAP.md | while read phase; do
-  num=$(echo "$phase" | grep -oE "[0-9]+")
-  padded=$(printf "%02d" $num)
-  ls .planning/phases/${padded}-* 2>/dev/null | head -1 || echo "W006: Phase ${num} in roadmap but no directory"
-done
-
-# Phase directories not in ROADMAP
-for dir in .planning/phases/*/; do
-  slug=$(basename "$dir" | sed 's/^[0-9]*-//')
-  grep -q "$slug" .planning/ROADMAP.md || echo "W007: Directory $(basename $dir) not in roadmap"
-done
+node -e "
+const fs=require('fs'),path=require('path');
+if(!fs.existsSync('.planning/ROADMAP.md'))process.exit(0);
+const roadmap=fs.readFileSync('.planning/ROADMAP.md','utf8');
+const phases=[...roadmap.matchAll(/^## Phase (\d+):/mg)].map(m=>m[1]);
+const phasesDir='.planning/phases';
+const dirs=fs.existsSync(phasesDir)?fs.readdirSync(phasesDir):[];
+for(const n of phases){
+  const pad=n.padStart(2,'0');
+  if(!dirs.some(d=>d.startsWith(pad+'-')))console.log('W006: Phase '+n+' in roadmap but no directory');
+}
+for(const d of dirs){
+  const slug=d.replace(/^\d+-/,'');
+  if(!roadmap.includes(slug))console.log('W007: Directory '+d+' not in roadmap');
+}
+"
 ```
 
 ### Plans Without Summaries
@@ -79,21 +88,18 @@ done
 ### Uncommitted Changes
 ```bash
 git status --short .planning/ 2>/dev/null | head -10
+# PowerShell: git status --short .planning/ 2>$null | Select-Object -First 10
 ```
 
 ### Config Fields
 ```bash
-# Check for required config keys
-python3 -c "
-import json
-cfg = json.load(open('.planning/config.json'))
-missing = []
-for key in ['mode', 'granularity', 'model_profile', 'learning_mode']:
-    if key not in cfg:
-        missing.append(key)
-if missing:
-    print('W004: config.json missing fields: ' + ', '.join(missing))
-" 2>/dev/null
+node -e "
+try{
+  const cfg=JSON.parse(require('fs').readFileSync('.planning/config.json','utf8'));
+  const missing=['mode','granularity','model_profile','learning_mode'].filter(k=>!(k in cfg));
+  if(missing.length)console.log('W004: config.json missing fields: '+missing.join(', '));
+}catch(e){}
+"
 ```
 
 ## Step 4: Format Output

package/learnship/workflows/insert-phase.md

@@ -31,7 +31,7 @@ Validate that the after-phase number is an integer.
 ## Step 2: Validate
 
 ```bash
-python3 -c "import os; print('OK' if os.path.exists('.planning/ROADMAP.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/ROADMAP.md') ? 'OK' : 'MISSING')"
 ```
 
 Check that phase `[N]` exists in ROADMAP.md:
@@ -56,7 +56,7 @@ Generate slug from description (lowercase, hyphens, max 40 chars).
 ## Step 4: Create Phase Directory
 
 ```bash
-mkdir -p ".planning/phases/[N].[M]-[SLUG]"
+node -e "require('fs').mkdirSync('.planning/phases/[N].[M]-[SLUG]',{recursive:true})"
 ```
 
 ## Step 5: Update ROADMAP.md

package/learnship/workflows/ls.md

@@ -13,7 +13,7 @@ The quickest way to answer "where am I and what do I do next?" Works for new use
 ## Step 1: Check for Project
 
 ```bash
-python3 -c "import os; print('EXISTS' if os.path.exists('.planning/PROJECT.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/PROJECT.md') ? 'EXISTS' : 'MISSING')"
 ```
 
 **If MISSING** — no project initialized yet. Display:
@@ -50,7 +50,7 @@ cat .planning/ROADMAP.md
 Find the 2–3 most recent SUMMARY.md files:
 
 ```bash
-find .planning -name "*-SUMMARY.md" -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -3
+node -e "const fs=require('fs'),path=require('path');function find(d){let r=[];try{for(const e of fs.readdirSync(d,{withFileTypes:true})){const f=path.join(d,e.name);r=r.concat(e.isDirectory()?find(f):e.name.endsWith('-SUMMARY.md')?[f]:[]);}}catch(e){}return r;}const files=find('.planning').map(f=>({f,t:fs.statSync(f).mtimeMs})).sort((a,b)=>b.t-a.t).slice(0,3).map(x=>x.f);files.forEach(f=>console.log(f));"
 ```
 
 Read each for a one-liner summary of what was accomplished.

package/learnship/workflows/map-codebase.md

@@ -33,7 +33,7 @@ Wait for response before continuing.
 ## Step 2: Create Output Directory
 
 ```bash
-mkdir -p .planning/codebase
+node -e "require('fs').mkdirSync('.planning/codebase',{recursive:true})"
 ```
 
 Expected output files:

package/learnship/workflows/milestone-retrospective.md

@@ -15,7 +15,9 @@ A structured learning retrospective after a milestone ships. Five focused questi
 Read the milestone that just shipped:
 ```bash
 ls .planning/milestones/ | sort -V | tail -3
+# PowerShell: Get-ChildItem .planning/milestones/ | Sort-Object Name | Select-Object -Last 3
 cat .planning/milestones/[VERSION]-ROADMAP.md 2>/dev/null | head -60
+# PowerShell: Get-Content .planning/milestones/[VERSION]-ROADMAP.md -ErrorAction SilentlyContinue | Select-Object -First 60
 ```
 
 Read all phase SUMMARY.md files from this milestone:

package/learnship/workflows/new-milestone.md

@@ -48,6 +48,7 @@ Follow the thread. When you have enough to write clear goals, ask for confirmati
 Read the last version from `.planning/milestones/`:
 ```bash
 ls .planning/milestones/ | grep -E "^v[0-9]" | sort -V | tail -3
+# PowerShell: Get-ChildItem .planning/milestones/ | Where-Object { $_.Name -match '^v[0-9]' } | Sort-Object Name | Select-Object -Last 3
 ```
 
 Propose the next version (e.g., `v1.0 → v1.1`, or `v2.0` for a major scope change). Confirm with user or let them specify.

package/learnship/workflows/new-project.md

@@ -6,16 +6,29 @@ description: Initialize a new project — questioning → research → requireme
 
 Initialize a new project with full context gathering, optional research, requirements scoping, and roadmap creation. This is the most leveraged moment in any project — deep questioning now means better plans, better execution, better outcomes.
 
+> **This workflow has 9 mandatory steps. You must complete every step in order. Do not skip, defer, or abbreviate any step. Check each one off as you complete it:**
+>
+> - [ ] Step 1 — Setup & codebase check
+> - [ ] Step 1b — Existing codebase scan (if applicable)
+> - [ ] Step 2 — Configuration questions
+> - [ ] Step 3 — Deep questioning (4 exchanges)
+> - [ ] Step 4 — Write and confirm PROJECT.md
+> - [ ] Step 5 — Research decision (ask user, wait for answer)
+> - [ ] Step 6 — Define requirements (interactive)
+> - [ ] Step 7 — Create and approve roadmap
+> - [ ] Step 8 — Generate AGENTS.md ← **mandatory, never skip**
+> - [ ] Step 9 — Done banner + next step
+
 ## Step 1: Setup
 
-<!-- LEARNSHIP_PLATFORM_LABEL -->
+You are running on **Windsurf**. Platform config directory: `.windsurf/`
 
 > **Routing protocol suspended.** While this workflow is running, every user message is an answer to a workflow question — not a task to route. Do NOT apply the request routing protocol until `/new-project` is fully complete and `.planning/PROJECT.md` exists.
 
 Check if `.planning/PROJECT.md` already exists:
 
 ```bash
-python3 -c "import os; print('EXISTS' if os.path.exists('.planning/PROJECT.md') else 'NEW')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/PROJECT.md') ? 'EXISTS' : 'NEW')"
 ```
 
 **If EXISTS:** Stop. Project already initialized. Use the `progress` workflow to see where you are.
@@ -23,11 +36,11 @@ python3 -c "import os; print('EXISTS' if os.path.exists('.planning/PROJECT.md')
 **Check for an existing codebase:**
 
 ```bash
-python3 -c "
-import os, pathlib
-files = [p for p in pathlib.Path('.').rglob('*') if p.is_file() and not any(x in p.parts for x in ['.git', 'node_modules', '.planning', '__pycache__', '.venv'])]
-print('HAS_CODE' if len(files) > 2 else 'BLANK')
-print(f'{len(files)} files')
+node -e "
+const fs=require('fs'),path=require('path');
+function walk(dir,skip){let n=0;try{for(const e of fs.readdirSync(dir,{withFileTypes:true})){const f=path.join(dir,e.name);if(skip.some(s=>f.includes(s)))continue;n+=e.isDirectory()?walk(f,skip):1;}}catch(e){}return n;}
+const n=walk('.',['/.git/','node_modules','.planning','__pycache__','.venv']);
+console.log(n>2?'HAS_CODE':'BLANK');console.log(n+' files');
 "
 ```
 
@@ -36,7 +49,7 @@ print(f'{len(files)} files')
 Check if git is initialized:
 
 ```bash
-python3 -c "import os; print('HAS_GIT' if os.path.isdir('.git') else 'NO_GIT')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.git') ? 'HAS_GIT' : 'NO_GIT')"
 ```
 
 **If NO_GIT:**
@@ -46,12 +59,12 @@ git init
 
 Add the platform config directory to `.gitignore` so AI platform files are not tracked in the project repo:
 ```bash
-<!-- LEARNSHIP_GITIGNORE_CMD -->
+grep -q '.windsurf/' .gitignore 2>/dev/null || echo '.windsurf/' >> .gitignore
 ```
 
 Create the planning directory:
 ```bash
-mkdir -p .planning/research
+node -e "require('fs').mkdirSync('.planning/research',{recursive:true})"
 ```
 
 ## Step 1b: Existing Codebase Scan (only if EXISTING_CODEBASE = true)
@@ -60,6 +73,7 @@ If `EXISTING_CODEBASE = true`, do a quick structural scan before questioning so
 
 ```bash
 find . -maxdepth 3 -not -path './.git/*' -not -path './node_modules/*' -not -path './.planning/*' -not -path './__pycache__/*' -not -path './.venv/*' | sort | head -40
+# PowerShell: Get-ChildItem -Recurse -Depth 3 | Where-Object { $_.FullName -notmatch '\.git|node_modules|\.planning|__pycache__|\.venv' } | Select-Object -First 40
 ```
 
 Note the tech stack, key directories, and any README content internally. Use this ONLY to ask sharper follow-up questions — never to infer the user's intent or skip ceremony steps.
@@ -92,7 +106,9 @@ Ask: "Which workflow agents should be enabled?"
 - **Plan Check** (recommended) — Verify plans achieve their goals before execution
 - **Verifier** (recommended) — Confirm deliverables match phase goals after execution
 
-<!-- LEARNSHIP_PARALLEL_BLOCK -->
+**Group D — Parallel execution:**
+
+Windsurf does not support real subagents. Parallelization is automatically set to `false`.
 
 Ask: "Commit planning docs to git?"
 - **Yes** (recommended) — Planning docs tracked in version control
@@ -208,15 +224,15 @@ If user requests changes: update PROJECT.md, show the full file again, re-ask th
 git add .planning/PROJECT.md && git commit -m "docs: initialize project"
 ```
 
-> 🛑 STOP. Do not proceed to Step 5 until you have asked the research question below AND received the user's explicit answer to it.
+> 🛑 STOP — **Step 4 complete. You MUST now ask the research question (Step 5) before writing any other file.** Do not write REQUIREMENTS.md. Do not write ROADMAP.md. Do not proceed to any other step. The next action is to ask the user exactly one question: whether to research the domain first.
 
 ## Step 5: Research Decision
 
-Ask: "Research the domain ecosystem before defining requirements?"
+Ask: **"Before I write the requirements — do you want me to research the domain ecosystem first?"**
 - **Research first** (recommended) — Discover standard stacks, expected features, architecture patterns
 - **Skip research** — I know this domain well, go straight to requirements
 
-> 🛑 STOP. Wait for the user's explicit choice before continuing. Do not default to "Research first" — wait for the user's actual reply.
+> 🛑 STOP. Wait for the user's explicit choice. Do not default to either option. Do not write REQUIREMENTS.md yet. Do not proceed until the user replies.
 
 **If Research first:**
 
@@ -325,6 +341,8 @@ Ask for approval:
 git add .planning/ROADMAP.md .planning/STATE.md .planning/REQUIREMENTS.md && git commit -m "docs: create roadmap ([N] phases)"
 ```
 
+> 🛑 STOP — **Step 7 complete. You MUST now generate AGENTS.md (Step 8) before anything else.** Do not display the done banner. Do not suggest next steps. Do not end the workflow. The roadmap is approved — AGENTS.md is next.
+
 ## Step 8: Generate AGENTS.md
 
 > **🔴 MANDATORY — This step must always be completed. Do not skip it, do not defer it, do not move to Step 9 without writing AGENTS.md to the project root. AGENTS.md is the persistent memory file that every future session depends on.**
@@ -336,6 +354,7 @@ Fill in the placeholder sections using information gathered in this session:
 **Project Structure** — derive from the project description and any existing directories:
 ```bash
 find . -maxdepth 2 -not -path './.git/*' -not -path './node_modules/*' -not -path './.planning/*' -type d | sort | head -20
+# PowerShell: Get-ChildItem -Directory -Recurse -Depth 2 | Where-Object { $_.FullName -notmatch '\.git|node_modules|\.planning' } | Select-Object -First 20
 ```
 
 Populate the `## Project Structure` tree with real directories and one-line descriptions.
@@ -378,7 +397,10 @@ Files created:
 - .planning/config.json
 [- .planning/research/ (if research was run)]
 
-▶ Next: discuss-phase 1 → plan-phase 1 → execute-phase 1
+▶ Next: `/discuss-phase 1` — **start here, not `/plan-phase`**
+
+The phase loop is: `discuss-phase` → `plan-phase` → `execute-phase` → `verify-work`
+`discuss-phase` is mandatory before planning — it captures your intent and writes the CONTEXT.md that plan-phase depends on. Skipping it means planning without context.
 
 > **Platform detected:** `[PLATFORM]` — parallelization is `[true/false]`
 ```

package/learnship/workflows/next.md

@@ -13,7 +13,7 @@ Reads project state and runs the right next workflow automatically. No need to r
 ## Step 1: Check for Project
 
 ```bash
-python3 -c "import os; print('EXISTS' if os.path.exists('.planning/PROJECT.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/PROJECT.md') ? 'EXISTS' : 'MISSING')"
 ```
 
 **If MISSING:**

package/learnship/workflows/pause-work.md

@@ -12,7 +12,7 @@ Create a `.continue-here.md` handoff file that captures complete work state. Ena
 
 Find the most recently active phase:
 ```bash
-find .planning/phases -name "*-PLAN.md" -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -1
+node -e "const fs=require('fs'),path=require('path');function find(d){let r=[];try{for(const e of fs.readdirSync(d,{withFileTypes:true})){const f=path.join(d,e.name);r=r.concat(e.isDirectory()?find(f):e.name.endsWith('-PLAN.md')?[f]:[]);}}catch(e){}return r;}const files=find('.planning/phases').map(f=>({f,t:fs.statSync(f).mtimeMs})).sort((a,b)=>b.t-a.t);if(files[0])console.log(files[0].f);"
 ```
 
 Extract the phase directory name from the result.

package/learnship/workflows/plan-milestone-gaps.md

@@ -13,6 +13,7 @@ Create all phases needed to close gaps identified by `audit-milestone`. One work
 Find the most recent audit file:
 ```bash
 ls -t .planning/*-MILESTONE-AUDIT.md 2>/dev/null | head -1
+# PowerShell: Get-ChildItem .planning/*-MILESTONE-AUDIT.md -ErrorAction SilentlyContinue | Sort-Object LastWriteTime -Descending | Select-Object -First 1
 ```
 
 If no audit file exists or status is `passed`:
@@ -74,6 +75,7 @@ Gap: Flow "User stays logged in" broken
 Find the highest existing phase number:
 ```bash
 ls .planning/phases/ | grep -E "^[0-9]" | sort -V | tail -1
+# PowerShell: Get-ChildItem .planning/phases/ | Where-Object { $_.Name -match '^[0-9]' } | Sort-Object Name | Select-Object -Last 1
 ```
 
 Gap closure phases continue from the highest existing phase + 1.
@@ -131,7 +133,7 @@ For each unsatisfied requirement being addressed:
 
 ```bash
 for each gap closure phase:
-  mkdir -p ".planning/phases/[NN]-[slug]"
+  node -e "require('fs').mkdirSync('.planning/phases/[NN]-[slug]',{recursive:true})"
 done
 ```
 

package/learnship/workflows/plan-phase.md

@@ -25,7 +25,7 @@ cat .planning/config.json
 
 Create the phase directory if it doesn't exist:
 ```bash
-mkdir -p ".planning/phases/[padded_phase]-[phase_slug]"
+node -e "require('fs').mkdirSync('.planning/phases/[padded_phase]-[phase_slug]',{recursive:true})"
 ```
 
 Check what already exists:

package/learnship/workflows/progress.md

@@ -9,7 +9,7 @@ Check where you are in the project, what's been done, and what comes next.
 ## Step 1: Check for Planning Structure
 
 ```bash
-python3 -c "import os; print('EXISTS' if os.path.exists('.planning/PROJECT.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/PROJECT.md') ? 'EXISTS' : 'MISSING')"
 ```
 
 If `.planning/` doesn't exist: stop — run `new-project` to initialize.
@@ -24,7 +24,7 @@ cat .planning/ROADMAP.md
 
 Find the 2-3 most recent SUMMARY.md files:
 ```bash
-find .planning -name "*-SUMMARY.md" -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -3
+node -e "const fs=require('fs'),path=require('path');function find(d){let r=[];try{for(const e of fs.readdirSync(d,{withFileTypes:true})){const f=path.join(d,e.name);r=r.concat(e.isDirectory()?find(f):e.name.endsWith('-SUMMARY.md')?[f]:[]);}}catch(e){}return r;}const files=find('.planning').map(f=>({f,t:fs.statSync(f).mtimeMs})).sort((a,b)=>b.t-a.t).slice(0,3).map(x=>x.f);files.forEach(f=>console.log(f));"
 ```
 
 Read each to extract what was recently accomplished (one-liner per plan).

package/learnship/workflows/quick.md

@@ -34,7 +34,7 @@ Display banner based on active flags:
 
 Check that a project exists:
 ```bash
-python3 -c "import os; print('OK' if os.path.exists('.planning/PROJECT.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/PROJECT.md') ? 'OK' : 'MISSING')"
 ```
 
 If PROJECT.md missing: stop — run `new-project` first. Quick tasks require an active project.
@@ -46,13 +46,15 @@ Generate a slug from the description (lowercase, hyphens, max 40 chars).
 Find the next task number:
 ```bash
 ls .planning/quick/ 2>/dev/null | grep -E "^[0-9]+" | sort -n | tail -1
+# PowerShell: Get-ChildItem .planning/quick/ -ErrorAction SilentlyContinue | Where-Object { $_.Name -match '^[0-9]+' } | Sort-Object Name | Select-Object -Last 1
 ```
 
 Set `NEXT_NUM` to the next available number (001, 002, etc.).
 
 Create task directory:
 ```bash
-mkdir -p ".planning/quick/${NEXT_NUM}-${SLUG}"
+node -e "require('fs').mkdirSync('.planning/quick/${NEXT_NUM}-${SLUG}',{recursive:true})"
+# PowerShell: New-Item -ItemType Directory -Force -Path ".planning/quick/${NEXT_NUM}-${SLUG}"
 ```
 
 Report: "Creating quick task ${NEXT_NUM}: ${DESCRIPTION}"
@@ -130,7 +132,7 @@ If `--full`: also include `must_haves` in plan frontmatter (truths, artifacts, k
 
 Verify plan was created (substitute actual NEXT_NUM and SLUG values):
 ```bash
-python3 -c "import os; print('OK' if os.path.exists('.planning/quick/NEXT_NUM-SLUG/NEXT_NUM-PLAN.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/quick/NEXT_NUM-SLUG/NEXT_NUM-PLAN.md') ? 'OK' : 'MISSING')"
 ```
 
 ## Step 5: Plan Check (only with `--full`)

package/learnship/workflows/release.md

@@ -168,10 +168,10 @@ curl -s -X POST \
     \"tag_name\": \"vX.Y.Z\",
     \"target_commitish\": \"main\",
     \"name\": \"vX.Y.Z — [Short title]\",
-    \"body\": $(echo "$RELEASE_NOTES" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))'),
+    \"body\": $(node -e "process.stdout.write(JSON.stringify(require('fs').readFileSync('/dev/stdin','utf8')))" <<< "$RELEASE_NOTES"),
     \"draft\": false,
     \"prerelease\": false
-  }" | python3 -c "import sys,json; r=json.load(sys.stdin); print(r.get('html_url', r.get('message','ERROR')))"
+  }" | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{const r=JSON.parse(d);console.log(r.html_url||r.message||'ERROR');})"
 ```
 
 If successful, the release URL is printed.
@@ -198,6 +198,7 @@ git remote -v
 ```bash
 git log --oneline public-main -3   # new release commit at top
 git tag --sort=-version:refname | head -5   # new tag at top
+# PowerShell: git tag --sort=-version:refname | Select-Object -First 5
 ```
 
 Open the release URL printed in Step 11 to confirm it looks correct on GitHub.

package/learnship/workflows/remove-phase.md

@@ -22,7 +22,7 @@ Example: remove-phase 7
 
 Check roadmap exists:
 ```bash
-python3 -c "import os; print('OK' if os.path.exists('.planning/ROADMAP.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/ROADMAP.md') ? 'OK' : 'MISSING')"
 ```
 
 ## Step 2: Verify the Phase is Future

package/learnship/workflows/research-phase.md

@@ -13,7 +13,7 @@ Run standalone domain research for a phase. Useful when the domain is unfamiliar
 ## Step 1: Validate Phase
 
 ```bash
-python3 -c "import os; print('OK' if os.path.exists('.planning/ROADMAP.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/ROADMAP.md') ? 'OK' : 'MISSING')"
 ```
 
 Find phase `[N]` in ROADMAP.md:

package/learnship/workflows/resume-work.md

@@ -9,9 +9,9 @@ Instantly restore full project context. Use when starting a new session, returni
 ## Step 1: Check Planning Structure
 
 ```bash
-python3 -c "import os; print('HAS_STATE' if os.path.exists('.planning/STATE.md') else 'NO_STATE')"
-python3 -c "import os; print('HAS_PROJECT' if os.path.exists('.planning/PROJECT.md') else 'NO_PROJECT')"
-python3 -c "import os; print('HAS_ROADMAP' if os.path.exists('.planning/ROADMAP.md') else 'NO_ROADMAP')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/STATE.md') ? 'HAS_STATE' : 'NO_STATE')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/PROJECT.md') ? 'HAS_PROJECT' : 'NO_PROJECT')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/ROADMAP.md') ? 'HAS_ROADMAP' : 'NO_ROADMAP')"
 ```
 
 If nothing exists: stop — run `new-project` to start a project.

package/learnship/workflows/set-profile.md

@@ -51,12 +51,12 @@ Stop.
 Update the `model_profile` field in `.planning/config.json`:
 
 ```bash
-python3 -c "
-import json
-cfg = json.load(open('.planning/config.json'))
-cfg['model_profile'] = '[profile]'
-json.dump(cfg, open('.planning/config.json', 'w'), indent=2)
-print('Updated.')
+node -e "
+const fs=require('fs');
+const cfg=JSON.parse(fs.readFileSync('.planning/config.json','utf8'));
+cfg.model_profile='[profile]';
+fs.writeFileSync('.planning/config.json',JSON.stringify(cfg,null,2));
+console.log('Updated.');
 "
 ```
 

package/learnship/workflows/settings.md

@@ -11,7 +11,7 @@ Interactive configuration editor for the current project. Updates `.planning/con
 ## Step 1: Ensure Config Exists
 
 ```bash
-python3 -c "import os; print('exists' if os.path.exists('.planning/config.json') else 'missing')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/config.json') ? 'exists' : 'missing')"
 ```
 
 If missing, create from template:

package/learnship/workflows/sync-upstream-skills.md

@@ -97,7 +97,7 @@ Confirm both clones succeeded — `SKILL.md` must exist in `$AGENTIC_LEARN_TMP`
 
 ```bash
 BACKUP_DIR="$(pwd)/.windsurf/skills/.upstream-backup-$(date +%Y%m%d-%H%M%S)"
-mkdir -p "$BACKUP_DIR"
+node -e "require('fs').mkdirSync('$BACKUP_DIR',{recursive:true})"
 
 cp -r "$(pwd)/.windsurf/skills/agentic-learning" "$BACKUP_DIR/agentic-learning"
 cp -r "$(pwd)/.windsurf/skills/impeccable" "$BACKUP_DIR/impeccable"

package/learnship/workflows/transition.md

@@ -27,7 +27,7 @@ find .planning/ -name "*.md" | sort
 
 Read the most recent SUMMARY.md files (last 3 phases):
 ```bash
-ls -t .planning/phases/*/*-SUMMARY.md 2>/dev/null | head -6
+node -e "const fs=require('fs'),path=require('path');function find(d){let r=[];try{for(const e of fs.readdirSync(d,{withFileTypes:true})){const f=path.join(d,e.name);r=r.concat(e.isDirectory()?find(f):e.name.endsWith('-SUMMARY.md')?[f]:[]);}}catch(e){}return r;}const files=find('.planning/phases').map(f=>({f,t:fs.statSync(f).mtimeMs})).sort((a,b)=>b.t-a.t).slice(0,6).map(x=>x.f);files.forEach(f=>console.log(f));"
 ```
 
 Check git status:

package/learnship/workflows/update.md

@@ -35,6 +35,7 @@ for loc in \
   "$HOME/favio/learnship" \
   "$HOME/learnship" \
   "$(find $HOME -name "install.sh" -path "*/learnship/*" 2>/dev/null | head -1 | xargs dirname 2>/dev/null)"; do
+# PowerShell: (Get-ChildItem $HOME -Recurse -Filter install.sh -ErrorAction SilentlyContinue | Where-Object { $_.FullName -match 'learnship' } | Select-Object -First 1).DirectoryName
   test -d "$loc/.windsurf/workflows" && SOURCE_DIR="$loc" && break
 done
 ```
@@ -93,7 +94,7 @@ Stop.
 For any workflow file that exists in install dir AND differs from source AND differs from the current source (meaning you modified it):
 
 ```bash
-mkdir -p "$INSTALL_DIR/local-patches"
+node -e "require('fs').mkdirSync('$INSTALL_DIR/local-patches',{recursive:true})"
 ```
 
 For each locally modified file:

package/learnship/workflows/validate-phase.md

@@ -22,7 +22,7 @@ If `nyquist_validation: false`: stop — "Validation is disabled. Enable it in `
 ## Step 2: Validate Phase
 
 ```bash
-python3 -c "import os; print('OK' if os.path.exists('.planning/ROADMAP.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/ROADMAP.md') ? 'OK' : 'MISSING')"
 ```
 
 Determine the phase directory:
@@ -61,6 +61,7 @@ Extract:
 find . \( -name "jest.config.*" -o -name "vitest.config.*" -o -name "pytest.ini" -o -name "pyproject.toml" \) -not -path "*/node_modules/*" 2>/dev/null
 
 find . \( -name "*.test.*" -o -name "*.spec.*" -o -name "test_*.py" \) -not -path "*/node_modules/*" 2>/dev/null | head -20
+# PowerShell: Get-ChildItem -Recurse | Where-Object { $_.Name -match '\.test\.|spec\.|^test_.*\.py' -and $_.FullName -notmatch 'node_modules' } | Select-Object -First 20
 ```
 
 Identify: test framework, how to run tests, existing test file patterns.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "learnship",
-  "version": "1.9.20",
+  "version": "1.9.22",
   "description": "Learn as you build. Build with intent. — A multi-platform agentic engineering system for Windsurf, Claude Code, Cursor, OpenCode, Gemini CLI, and Codex: spec-driven workflows, integrated learning, and production-grade design.",
   "keywords": [
     "agentic",

package/references/planning-config.md

@@ -40,7 +40,7 @@ Configuration options for `.planning/` directory behavior.
 
 ```bash
 # Read commit_docs from config.json
-COMMIT_DOCS=$(python3 -c "import json; c=json.load(open('.planning/config.json')); print(c.get('planning',{}).get('commit_docs','true'))" 2>/dev/null || echo 'true')
+COMMIT_DOCS=$(node -e "try{const c=JSON.parse(require('fs').readFileSync('.planning/config.json','utf8'));process.stdout.write(String((c.planning||{}).commit_docs??'true'));}catch(e){process.stdout.write('true');}" 2>/dev/null || echo 'true')
 ```
 
 **Auto-detection:** If `.planning/` is gitignored, treat `commit_docs` as `false` regardless of config.json. This prevents git errors.
@@ -139,7 +139,7 @@ To use uncommitted mode:
 
 Read config directly:
 ```bash
-python3 -c "import json; c=json.load(open('.planning/config.json')); g=c.get('git',{}); print(g.get('branching_strategy','none'), g.get('phase_branch_template','phase-{phase}-{slug}'), g.get('milestone_branch_template','{milestone}-{slug}'))"
+node -e "const c=JSON.parse(require('fs').readFileSync('.planning/config.json','utf8')),g=c.git||{};console.log(g.branching_strategy||'none',g.phase_branch_template||'phase-{phase}-{slug}',g.milestone_branch_template||'{milestone}-{slug}')"
 ```
 
 **Branch creation:**