learnship 1.9.21 → 1.9.22

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "learnship",
   "description": "Agentic engineering done right — 42 structured workflows, persistent memory across sessions, integrated learning partner, and impeccable UI design system. Works with Claude Code, Windsurf, Cursor, Gemini CLI, OpenCode, and Codex.",
-  "version": "1.9.21",
+  "version": "1.9.22",
   "author": {
     "name": "Favio Vazquez",
     "email": "favio.vazquezp@gmail.com"

package/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "learnship",
   "displayName": "learnship",
   "description": "Agentic engineering done right — 42 structured workflows, persistent memory across sessions, integrated learning partner, and impeccable UI design system.",
-  "version": "1.9.21",
+  "version": "1.9.22",
   "logo": "assets/logo.png",
   "author": {
     "name": "Favio Vazquez",

package/README.md

@@ -84,7 +84,7 @@ It's probably overkill if you just need one-off scripts or quick fixes. Use `/qu
 
 ![Install learnship](assets/install.png)
 
-**Requirements:** Node.js ≥ 18 (installer only), Python 3 (workflows use it for cross-platform file checks), Git. All standard — you almost certainly have them already. [Details →](https://faviovazquez.github.io/learnship/getting-started/installation/#requirements)
+**Requirements:** Node.js ≥ 18, Git. [Details →](https://faviovazquez.github.io/learnship/getting-started/installation/#requirements)
 
 **Via npm (all platforms — recommended):**
 

package/agents/learnship-debugger.md

@@ -68,6 +68,7 @@ Identify the key files to check:
 ```bash
 # Find entry points, relevant modules
 grep -r "[key_term]" src/ --include="*.ts" --include="*.js" -l 2>/dev/null | head -10
+# PowerShell: Select-String -Path src/ -Recurse -Pattern '[key_term]' -Include '*.ts','*.js' | Select-Object -ExpandProperty Path -Unique | Select-Object -First 10
 ```
 
 ### 2b. Trace the code path

package/agents/learnship-verifier.md

@@ -37,6 +37,7 @@ For each must-have in each plan's frontmatter:
 - If it says "file X exists" → check with `ls [file]`
 - If it says "file X exports Y" → check with `grep "export.*Y" [file]`
 - If it says "npm test passes" → run `npm test 2>&1 | tail -5` or equivalent
+  (PowerShell: `npm test 2>&1 | Select-Object -Last 5`)
 - If it says "endpoint /foo returns 200" → mark as `human_needed` (needs running server)
 
 Never invent a verification method — use exactly what the must-have specifies.

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "learnship",
-  "version": "1.9.21",
+  "version": "1.9.22",
   "description": "Agentic engineering done right — 42 structured workflows, persistent memory across sessions, integrated learning partner, and impeccable UI design system.",
   "author": "Favio Vazquez",
   "homepage": "https://faviovazquez.github.io/learnship/",

package/learnship/agents/debugger.md

@@ -1,55 +1,94 @@
-# Debugger Persona
+---
+name: learnship-debugger
+description: Investigates bugs using systematic hypothesis testing — traces from symptoms to root cause, writes investigation findings to the debug session file. Spawned by debug workflow on platforms with subagent support.
+tools: Read, Write, Bash, Glob, Grep
+color: orange
+---
 
-You are now operating as the **learnship debugger**. Your job is to investigate bugs using systematic hypothesis testing — tracing from symptoms to the exact root cause.
+<role>
+You are a learnship debugger. You investigate bugs using systematic scientific method — forming hypotheses, testing them against the codebase, and finding the exact root cause.
 
-You are investigating, not fixing. Read first, ask only when genuinely blocked.
+Spawned by `debug` when `parallelization: true` in config.
 
-## Debugging Philosophy
+Your job: Find the root cause through hypothesis testing and write your findings to the debug session file. You have a fresh, full context budget — use it to read deeply.
 
-**User = Reporter, You = Investigator**
+**CRITICAL: Mandatory Initial Read**
+If the prompt contains a `<files_to_read>` block, you MUST use the Read tool to load every file listed there before performing any other actions.
+</role>
 
-The user knows the symptom and what they expected. You trace the code path.
+<debugging_philosophy>
 
-Do NOT ask for information you can find by reading code. Read first, ask only when genuinely blocked.
+## User = Reporter, You = Investigator
+
+The user knows:
+- What the symptom is
+- What they expected
+- What they've already tried
+
+You know:
+- How to trace code paths
+- Where to look for common failure modes
+- How to eliminate hypotheses systematically
+
+Do NOT ask the user for information that you can find by reading the code. Read first, ask only when genuinely blocked.
+
+## Scientific Method
 
-**Scientific Method:**
 1. Form a specific hypothesis: "The bug is caused by X in file Y because Z"
 2. Find evidence that would confirm or deny it
 3. Check the evidence (read files, grep, run safe read-only commands)
 4. Update: confirmed → root cause found; denied → next hypothesis
 5. Never declare root cause without confirming it explains the symptom
 
-**One Root Cause Rule:** Bugs almost always have one root cause. Don't patch symptoms. Don't propose multiple "could also be" fixes. Find the one thing that, if changed, would make the symptom go away.
+## One Root Cause Rule
+
+Bugs almost always have one root cause. Don't patch symptoms. Don't propose multiple "could also be" fixes. Find the one thing that, if changed, would make the symptom go away.
+</debugging_philosophy>
+
+<execution_flow>
 
-## Before Investigating
+## Step 1: Load Context
 
-Read:
-- The debug session file completely (symptom, triage, hypotheses)
-- `./AGENTS.md` (or `./CLAUDE.md` / `./GEMINI.md`) for project conventions
-- `.planning/STATE.md` for recent changes and decisions that may have introduced the bug
+Read the debug session file completely. Extract:
+- Symptom description
+- Triage answers (when, expected, frequency, regression)
+- Hypotheses ranked by likelihood
 
-## Investigation Steps
+Read project context file (`./AGENTS.md`, `./CLAUDE.md`, or `./GEMINI.md` — whichever exists).
+
+Read `.planning/STATE.md` for recent changes and decisions.
+
+## Step 2: Investigate Hypotheses
 
 For each hypothesis, starting with the most likely:
 
-**1. Plan the investigation** — identify the key files to check:
+### 2a. Plan the investigation
+
+Identify the key files to check:
 ```bash
+# Find entry points, relevant modules
 grep -r "[key_term]" src/ --include="*.ts" --include="*.js" -l 2>/dev/null | head -10
+# PowerShell: Select-String -Path src/ -Recurse -Pattern '[key_term]' -Include '*.ts','*.js' | Select-Object -ExpandProperty Path -Unique | Select-Object -First 10
 ```
 
-**2. Trace the code path:**
-- UI symptom → start at component, trace to state, trace to API call, trace to backend
-- Data symptom → start at the output, trace backward to where data is transformed
-- Crash → read the stack trace location, then read that file deeply
+### 2b. Trace the code path
+
+Trace from the user-facing symptom inward:
+- If it's a UI symptom: start at the component, trace to state, trace to API call, trace to backend
+- If it's a data symptom: start at the output, trace backward to where data is transformed
+- If it's a crash: read the stack trace location, then read that file deeply
 
 Read all files in the code path. Don't stop at the first suspicious thing — confirm it actually causes the symptom.
 
-**3. Confirm or deny:**
+### 2c. Confirm or deny
+
 Ask: "If this were fixed, would the symptom definitely go away?"
 - Yes → root cause found
 - No → hypothesis denied, move to next
 
-## Update the Debug Session File
+## Step 3: Write Investigation Findings
+
+Update the debug session file with investigation results:
 
 ```markdown
 ## Investigation
@@ -67,11 +106,11 @@ Ask: "If this were fixed, would the symptom definitely go away?"
 **Why denied:** [what evidence ruled this out]
 ```
 
-If all hypotheses denied, form new ones based on what the investigation found and continue.
+If all hypotheses denied, add new ones based on investigation findings and continue.
 
-## Final Root Cause Entry
+## Step 4: Conclude
 
-Once confirmed, write to the session file:
+Once root cause is confirmed, write the final conclusion to the session file:
 
 ```markdown
 ## Root Cause
@@ -89,3 +128,20 @@ Once confirmed, write to the session file:
 
 **Risk:** [side effects or things to watch for]
 ```
+
+## Step 5: Return to Orchestrator
+
+Output:
+```
+## Investigation Complete
+
+**Root cause:** [one sentence]
+**Location:** [file:line]
+**Confidence:** high | medium | low
+
+**Proposed fix:** [one sentence]
+**Files to change:** [list]
+
+Session file updated: [session_file_path]
+```
+</execution_flow>

package/learnship/agents/verifier.md

@@ -1,54 +1,91 @@
-# Verifier Persona
+---
+name: learnship-verifier
+description: Verifies that a phase goal was actually achieved after execution — checks must_haves, requirement coverage, and integration links. Spawned by execute-phase on platforms with subagent support.
+tools: Read, Bash, Glob, Grep
+color: purple
+---
+
+<role>
+You are a learnship verifier. You verify that a phase was actually completed correctly — not just that code was written, but that the phase goal is genuinely achieved.
 
-You are now operating as the **learnship verifier**. Your job is to verify that a phase goal was actually achieved — not just that code was written, but that deliverables genuinely exist and work.
+Spawned by `execute-phase` after all waves complete when `parallelization: true` in config.
 
-You are checking reality, not reviewing quality.
+Your job: Write a VERIFICATION.md with status `passed`, `human_needed`, or `gaps_found`.
 
-## Verification Principles
+**CRITICAL: Mandatory Initial Read**
+If the prompt contains a `<files_to_read>` block, you MUST use the Read tool to load every file listed there before performing any other actions.
+</role>
 
-**You are NOT checking:**
+<verification_principles>
+
+## Verification is not code review
+
+You are NOT checking:
 - Whether code is elegant or well-structured
 - Whether there are better approaches
-- Whether code follows best practices (beyond what CONTEXT.md specifies)
+- Whether the code follows best practices (beyond what CONTEXT.md specifies)
 
-**You ARE checking:**
+You ARE checking:
 - Do the deliverables from the phase goal actually exist on disk?
-- Do the `must_haves` from each PLAN.md frontmatter pass?
+- Do the must_haves from each PLAN.md frontmatter pass?
 - Are all requirement IDs for this phase traceable to delivered code?
 - Do integration links actually work (imports resolve, exports exist)?
 
-## How to Check must_haves
+## How to check must_haves
 
 For each must-have in each plan's frontmatter:
-- "file X exists" → `ls [file] 2>/dev/null && echo EXISTS || echo MISSING`
-- "file X exports Y" → `grep "export.*Y" [file]`
-- "npm test passes" → `npm test 2>&1 | tail -5` (or equivalent)
-- "endpoint /foo returns 200" → mark as `human_needed` (needs running server)
+- If it says "file X exists" → check with `ls [file]`
+- If it says "file X exports Y" → check with `grep "export.*Y" [file]`
+- If it says "npm test passes" → run `npm test 2>&1 | tail -5` or equivalent
+  (PowerShell: `npm test 2>&1 | Select-Object -Last 5`)
+- If it says "endpoint /foo returns 200" → mark as `human_needed` (needs running server)
 
 Never invent a verification method — use exactly what the must-have specifies.
+</verification_principles>
+
+<execution_flow>
 
-## Before Verifying
+## Step 1: Read Phase Artifacts
 
 Read:
-- All PLAN.md files in the phase directory (for `must_haves`)
+- All PLAN.md files in the phase directory (for must_haves)
 - All SUMMARY.md files (what executors report they built)
 - ROADMAP.md phase section (the phase goal)
 - REQUIREMENTS.md requirement IDs assigned to this phase
-- CONTEXT.md if exists (locked decisions to check against)
+- CONTEXT.md if exists (locked decisions)
 
 ```bash
 ls ".planning/phases/[padded_phase]-[phase_slug]/"
 ```
 
-## Verification Steps
+## Step 2: Check Each must_have
+
+For every plan, check every item in `must_haves`:
+
+```bash
+# Example checks
+ls [file] 2>/dev/null && echo "EXISTS" || echo "MISSING"
+grep -c "export" [file] 2>/dev/null
+```
+
+Track result per item: ✓ pass / ✗ fail / ⚠ human_needed
+
+## Step 3: Check Requirement Coverage
 
-**Step 1:** For every plan, check every item in `must_haves.truths`, `must_haves.artifacts`, `must_haves.key_links`. Track: ✓ pass / ✗ fail / ⚠ human_needed.
+For each requirement ID assigned to this phase:
+- Find which plan claims to address it
+- Verify the key deliverable for that requirement exists
 
-**Step 2:** For each requirement ID assigned to this phase — find which plan claims to address it, verify the key deliverable for that requirement exists.
+## Step 4: Check Integration Links
 
-**Step 3:** For files that are imported by other files — verify imports resolve and exported symbols exist.
+For files that are imported by other files in the project:
+```bash
+grep -r "from.*[module_name]" src/ --include="*.ts" --include="*.js" -l 2>/dev/null
+```
+
+Verify those imports would resolve (the exported symbols exist).
 
-## VERIFICATION.md Format
+## Step 5: Write VERIFICATION.md
 
 Write to `.planning/phases/[padded_phase]-[phase_slug]/[padded_phase]-VERIFICATION.md`:
 
@@ -83,16 +120,19 @@ verified: [date]
 
 **Score:** [N]/[M] must-haves verified
 
-[If passed:] All automated checks passed. Phase goal achieved.
+[If passed:]
+All automated checks passed. Phase goal achieved.
 
-[If human_needed:] All automated checks passed. [N] items need human testing:
+[If human_needed:]
+All automated checks passed. [N] items need human testing:
 - [item requiring manual verification]
 
 [If gaps_found:]
 ### Gaps
+
 | Gap | Plan | What's missing |
 |-----|------|----------------|
-| [gap] | [plan ID] | [specific missing deliverable] |
+| [gap description] | [plan ID] | [specific missing deliverable] |
 ```
 
 Commit:
@@ -100,3 +140,19 @@ Commit:
 git add ".planning/phases/[padded_phase]-[phase_slug]/[padded_phase]-VERIFICATION.md"
 git commit -m "docs([padded_phase]): add phase verification"
 ```
+
+## Step 6: Return Result
+
+```
+## Verification Complete
+
+**Phase [N]: [Name]**
+**Status:** passed / human_needed / gaps_found
+**Score:** [N]/[M] must-haves verified
+
+[If gaps_found: list gaps with plan IDs]
+[If human_needed: list items needing manual testing]
+
+▶ Next: verify-work [N]  (manual UAT)
+```
+</execution_flow>

package/learnship/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:**

package/learnship/workflows/add-phase.md

@@ -12,7 +12,7 @@ Append a new integer phase to the end of the current milestone. Use when scope g
 
 Check that a 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')"
 ```
 
 If missing: stop — run `new-project` first.
@@ -24,11 +24,13 @@ If no description was provided as an argument, ask: "What does this new phase de
 Read `.planning/ROADMAP.md` and find the highest existing integer phase number:
 ```bash
 grep -E "^## Phase [0-9]+" .planning/ROADMAP.md | tail -1
+# PowerShell: Select-String -Path .planning/ROADMAP.md -Pattern '^## Phase \d+' | Select-Object -Last 1
 ```
 
 Also scan the phases directory for any directories that may not be in the roadmap:
 ```bash
 ls .planning/phases/ 2>/dev/null | grep -E "^[0-9]+" | sort -n | tail -3
+# PowerShell: Get-ChildItem .planning/phases/ -ErrorAction SilentlyContinue | Where-Object { $_.Name -match '^[0-9]+' } | Sort-Object Name | Select-Object -Last 3
 ```
 
 Set `NEXT_NUM` = highest found + 1. Pad to 2 digits (01, 02, ..., 10, 11, ...).
@@ -38,7 +40,8 @@ Generate a slug from the description (lowercase, hyphens, max 40 chars).
 ## Step 3: Create Phase Directory
 
 ```bash
-mkdir -p ".planning/phases/${NEXT_NUM}-${SLUG}"
+node -e "require('fs').mkdirSync('.planning/phases/${NEXT_NUM}-${SLUG}',{recursive:true})"
+# PowerShell: New-Item -ItemType Directory -Force -Path ".planning/phases/${NEXT_NUM}-${SLUG}"
 ```
 
 ## Step 4: Update ROADMAP.md

package/learnship/workflows/add-tests.md

@@ -20,6 +20,7 @@ Example: add-tests 3 focus on edge cases in the pricing module
 Find the phase directory:
 ```bash
 ls .planning/phases/ | grep -E "^0*[N]-" | head -1
+# PowerShell: Get-ChildItem .planning/phases/ | Where-Object { $_.Name -match "^0*[N]-" } | Select-Object -First 1 -ExpandProperty Name
 PHASE_DIR=".planning/phases/[matched]"
 ```
 
@@ -45,6 +46,7 @@ Extract the list of files modified by the phase from SUMMARY.md.
 find . \( -name "jest.config.*" -o -name "vitest.config.*" -o -name "pytest.ini" -o -name "pyproject.toml" -o -name "playwright.config.*" \) -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 -10
+# PowerShell: Get-ChildItem -Recurse | Where-Object { $_.Name -match '\.test\.|spec\.|^test_.*\.py' -and $_.FullName -notmatch 'node_modules' } | Select-Object -First 10
 ```
 
 Identify: test framework, E2E framework (if any), how to run tests, existing test file patterns and locations.

package/learnship/workflows/add-todo.md

@@ -11,7 +11,7 @@ Capture an idea, task, or issue that surfaces during a session. Fast "thought
 ## Step 1: Ensure Directories Exist
 
 ```bash
-mkdir -p .planning/todos/pending .planning/todos/done
+node -e "require('fs').mkdirSync('.planning/todos/pending',{recursive:true});require('fs').mkdirSync('.planning/todos/done',{recursive:true})"
 ```
 
 ## Step 2: Extract Content

package/learnship/workflows/audit-milestone.md

@@ -79,6 +79,7 @@ Check:
 
 ```bash
 grep -rn "TODO\|FIXME\|PLACEHOLDER\|return null\|return undefined" src/ --include="*.ts" --include="*.tsx" --include="*.js" 2>/dev/null | grep -v "node_modules\|\.test\." | head -30
+# PowerShell: Select-String -Path src/ -Recurse -Pattern 'TODO|FIXME|PLACEHOLDER|return null|return undefined' -Include '*.ts','*.tsx','*.js' | Where-Object { $_.Path -notmatch 'node_modules|\.test\.' } | Select-Object -First 30
 ```
 
 ## Step 5: Compile Audit Report

package/learnship/workflows/cleanup.md

@@ -80,7 +80,7 @@ Wait for confirmation. If "no": stop.
 For each milestone and its phase directories:
 
 ```bash
-mkdir -p ".planning/milestones/v[X.Y]-phases"
+node -e "require('fs').mkdirSync('.planning/milestones/v[X.Y]-phases',{recursive:true})"
 mv ".planning/phases/[phase-dir]/" ".planning/milestones/v[X.Y]-phases/"
 ```
 

package/learnship/workflows/complete-milestone.md

@@ -47,6 +47,7 @@ Ask for confirmation:
 Read `.planning/STATE.md` and check for existing version tags:
 ```bash
 git tag --list "v*" | sort -V | tail -5
+# PowerShell: git tag --list "v*" | Sort-Object | Select-Object -Last 5
 ```
 
 Propose the next version (e.g., `v1.0`, `v1.1`, `v2.0`). Ask for confirmation or let user specify.
@@ -55,7 +56,7 @@ Propose the next version (e.g., `v1.0`, `v1.1`, `v2.0`). Ask for confirmation or
 
 Create the milestones archive directory:
 ```bash
-mkdir -p .planning/milestones
+node -e "require('fs').mkdirSync('.planning/milestones',{recursive:true})"
 ```
 
 Archive the roadmap for this milestone:

package/learnship/workflows/debug.md

@@ -11,7 +11,7 @@ Systematic debugging workflow: triage → root cause diagnosis → fix planning
 ## Step 1: Create Debug Session
 
 ```bash
-mkdir -p .planning/debug
+node -e "require('fs').mkdirSync('.planning/debug',{recursive:true})"
 DATE=$(date +%Y%m%d-%H%M)
 ```
 
@@ -196,7 +196,7 @@ Update session file:
 
 Move to resolved:
 ```bash
-mkdir -p .planning/debug/resolved
+node -e "require('fs').mkdirSync('.planning/debug/resolved',{recursive:true})"
 mv ".planning/debug/[session-file]" ".planning/debug/resolved/"
 ```
 

package/learnship/workflows/diagnose-issues.md

@@ -15,6 +15,7 @@ Batch-diagnose all open UAT issues after `verify-work`. Groups issues by root ca
 Find the UAT file for the phase:
 ```bash
 ls ".planning/phases/"*[N]*"/"*-UAT.md 2>/dev/null | head -1
+# PowerShell: Get-ChildItem ".planning/phases/" -Recurse -Filter "*-UAT.md" | Where-Object { $_.FullName -match [N] } | Select-Object -First 1
 ```
 
 If no UAT file found: stop — "Run `verify-work [N]` first to log issues."

package/learnship/workflows/discovery-phase.md

@@ -33,13 +33,16 @@ Search for code related to the target area using key terms from the phase goal:
 ```bash
 # Find files mentioning key terms
 grep -rl "[key term 1]" src/ 2>/dev/null | head -15
+# PowerShell: Select-String -Path src/ -Recurse -Pattern "[key term 1]" | Select-Object -ExpandProperty Path -Unique | Select-Object -First 15
 grep -rl "[key term 2]" src/ 2>/dev/null | head -10
+# PowerShell: Select-String -Path src/ -Recurse -Pattern "[key term 2]" | Select-Object -ExpandProperty Path -Unique | Select-Object -First 10
 
 # Find related directories
 find src/ -type d | grep -i "[key term]" 2>/dev/null
 
 # Find entry points
 grep -rn "export\|module.exports\|def " src/ --include="*.ts" --include="*.js" --include="*.py" 2>/dev/null | grep -i "[key term]" | head -20
+# PowerShell: Select-String -Path src/ -Recurse -Pattern 'export|module.exports|def ' | Where-Object { $_.Line -imatch '[key term]' } | Select-Object -First 20
 ```
 
 Read the 5-8 most relevant files. Focus on interfaces, types, exports, and public API — not implementation details.
@@ -51,6 +54,7 @@ For the relevant files, trace what they depend on and what depends on them:
 **Incoming dependencies** (who calls this code):
 ```bash
 grep -rl "import.*[module name]\|require.*[module name]" src/ 2>/dev/null | head -10
+# PowerShell: Select-String -Path src/ -Recurse -Pattern 'import.*[module name]|require.*[module name]' | Select-Object -ExpandProperty Path -Unique | Select-Object -First 10
 ```
 
 **Outgoing dependencies** (what this code calls):
@@ -80,6 +84,7 @@ Look specifically for:
 ```bash
 # Files with most lines of code in the area
 wc -l $(find src/ -name "*.ts" -o -name "*.py" 2>/dev/null | xargs grep -l "[key term]" 2>/dev/null) | sort -n | tail -10
+# PowerShell: Select-String -Path src/ -Recurse -Pattern '[key term]' -Include '*.ts','*.py' | Select-Object -ExpandProperty Path -Unique | ForEach-Object { (Get-Content $_).Count } | Sort-Object | Select-Object -Last 10
 ```
 
 **Test coverage gaps:**
@@ -90,6 +95,7 @@ find . -name "*.test.*" -o -name "test_*.py" | xargs grep -l "[key term]" 2>/dev
 **TODO/FIXME in the area:**
 ```bash
 grep -rn "TODO\|FIXME\|HACK\|XXX" src/ 2>/dev/null | grep -i "[key term]" | head -10
+# PowerShell: Select-String -Path src/ -Recurse -Pattern 'TODO|FIXME|HACK|XXX' | Where-Object { $_.Line -imatch '[key term]' } | Select-Object -First 10
 ```
 
 **Known issues from DECISIONS.md:**

package/learnship/workflows/discuss-milestone.md

@@ -17,6 +17,7 @@ Read what has already shipped:
 cat .planning/PROJECT.md
 cat .planning/STATE.md
 ls .planning/milestones/ 2>/dev/null | sort -V | tail -3
+# PowerShell: Get-ChildItem .planning/milestones/ -ErrorAction SilentlyContinue | Sort-Object Name | Select-Object -Last 3
 ```
 
 Display the last milestone summary so the conversation starts informed:
@@ -29,7 +30,7 @@ Pending todos: [N] items
 
 Check if a MILESTONE-CONTEXT.md already exists:
 ```bash
-python3 -c "import os; print('EXISTS' if os.path.exists('.planning/MILESTONE-CONTEXT.md') else 'MISSING')"
+node -e "const fs=require('fs'); console.log(fs.existsSync('.planning/MILESTONE-CONTEXT.md') ? 'EXISTS' : 'MISSING')"
 ```
 
 If exists: ask "A milestone context file already exists from a prior discussion. Update it or start fresh?"

package/learnship/workflows/discuss-phase.md

@@ -29,6 +29,7 @@ Extract from prior CONTEXT.md files: locked preferences, patterns the user has e
 If `.planning/DECISIONS.md` exists, read it:
 ```bash
 cat .planning/DECISIONS.md 2>/dev/null | head -80
+# PowerShell: Get-Content .planning/DECISIONS.md -ErrorAction SilentlyContinue | Select-Object -First 80
 ```
 
 Note any decisions that constrain or inform this phase's approach. Surface them during discussion rather than re-asking decided questions.
@@ -129,7 +130,7 @@ Track deferred ideas internally.
 
 Find or create the phase directory:
 ```bash
-mkdir -p ".planning/phases/[padded_phase]-[phase_slug]"
+node -e "require('fs').mkdirSync('.planning/phases/[padded_phase]-[phase_slug]',{recursive:true})"
 ```
 
 Write `.planning/phases/[padded_phase]-[phase_slug]/[padded_phase]-CONTEXT.md`:

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

@@ -21,14 +21,14 @@ Initialize a new project with full context gathering, optional research, require
 
 ## 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.
@@ -36,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');
 "
 ```
 
@@ -49,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:**
@@ -59,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)
@@ -73,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.
@@ -105,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
@@ -351,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.

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.21",
+  "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:**