@atlashub/smartstack-cli 2.9.0 → 3.1.0

package/templates/skills/gitflow/_shared.md

@@ -4,6 +4,95 @@
 
 ---
 
+## DETECT_PLATFORM
+
+Detects the current platform (WSL, Windows, macOS, Linux) and shell environment.
+Must be called before any path operations.
+
+```bash
+detect_platform() {
+  # WSL detection (highest priority - WSL reports as Linux but needs path translation)
+  if [ -f /proc/version ] && grep -qi "microsoft\|wsl" /proc/version 2>/dev/null; then
+    GF_PLATFORM="wsl"
+    GF_SHELL="bash"
+  elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "mingw"* ]] || [[ "$OSTYPE" == "cygwin" ]]; then
+    GF_PLATFORM="windows"
+    GF_SHELL="gitbash"
+  elif [[ -n "$WINDIR" ]] || [[ -n "$SystemRoot" ]]; then
+    GF_PLATFORM="windows"
+    GF_SHELL="powershell"
+  elif [[ "$OSTYPE" == "darwin"* ]]; then
+    GF_PLATFORM="macos"
+    GF_SHELL="zsh"
+  elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+    GF_PLATFORM="linux"
+    GF_SHELL="bash"
+  else
+    GF_PLATFORM="unknown"
+    GF_SHELL="bash"
+  fi
+}
+```
+
+---
+
+## NORMALIZE_PATH
+
+Path translation functions for cross-platform compatibility (Windows ↔ WSL ↔ POSIX).
+
+```bash
+# Translates a path to the format expected by the CURRENT platform
+normalize_path_for_platform() {
+  local input_path="$1"
+  case "$GF_PLATFORM" in
+    wsl)
+      # Windows path → WSL path: D:\foo\bar or D:/foo/bar → /mnt/d/foo/bar
+      if [[ "$input_path" =~ ^[A-Za-z]:[\\/] ]]; then
+        local drive=$(echo "${input_path:0:1}" | tr '[:upper:]' '[:lower:]')
+        local rest="${input_path:2}"
+        rest="${rest//\\//}"
+        echo "/mnt/$drive$rest"
+      else
+        echo "$input_path"
+      fi
+      ;;
+    *)
+      # Normalize backslashes to forward slashes
+      echo "${input_path//\\//}"
+      ;;
+  esac
+}
+
+# Translates a path to storage-neutral format for config.json (forward slashes, drive letter)
+normalize_path_for_storage() {
+  local input_path="$1"
+  case "$GF_PLATFORM" in
+    wsl)
+      # WSL path → Windows-style for config: /mnt/d/foo/bar → D:/foo/bar
+      if [[ "$input_path" =~ ^/mnt/([a-z])/(.*) ]]; then
+        local drive=$(echo "${BASH_REMATCH[1]}" | tr '[:lower:]' '[:upper:]')
+        echo "${drive}:/${BASH_REMATCH[2]}"
+      else
+        echo "$input_path"
+      fi
+      ;;
+    *)
+      # Normalize backslashes to forward slashes
+      echo "${input_path//\\//}"
+      ;;
+  esac
+}
+
+# Returns current directory in platform-appropriate format
+get_current_dir() {
+  local raw_pwd
+  raw_pwd="$(pwd)"
+  normalize_path_for_platform "$raw_pwd"
+}
+```
+
+---
+
 ## DETECT_PROVIDER
 
 Detects GitHub or Azure DevOps from remote URL.
@@ -83,12 +172,18 @@ Reads GitFlow configuration from config.json. Exposes all variables needed by st
 
 ```bash
 read_gitflow_config() {
+  # Detect platform first (needed for path translation)
+  detect_platform
+
   local CONFIG_FILE
   CONFIG_FILE=$(resolve_gitflow_config_path) || {
     echo "❌ GitFlow config not found. Run /gitflow init first."
     return 1
   }
 
+  # Config version
+  GF_CONFIG_VERSION=$(grep -oP '"version":\s*"\K[^"]+' "$CONFIG_FILE" | head -1)
+
   # Repository
   GF_PROJECT_NAME=$(grep -oP '"name":\s*"\K[^"]+' "$CONFIG_FILE" | head -1)
   GF_ROOT_FOLDER=$(grep -oP '"rootFolder":\s*"\K[^"]+' "$CONFIG_FILE" | head -1)
@@ -119,6 +214,14 @@ read_gitflow_config() {
   GF_VERSION=$(grep -oP '"current":\s*"\K[^"]+' "$CONFIG_FILE" | head -1)
   GF_TAG_PREFIX=$(grep -oP '"tagPrefix":\s*"\K[^"]+' "$CONFIG_FILE" | head -1)
 
+  # Platform (v2.1.0+, optional)
+  GF_CONFIG_PLATFORM=$(grep -oP '"detected":\s*"\K[^"]+' "$CONFIG_FILE" | head -1)
+  GF_CONFIG_PLATFORM=${GF_CONFIG_PLATFORM:-$GF_PLATFORM}
+
+  # Workspace (v2.1.0+, optional)
+  GF_WORKSPACE_PATH=$(grep -A1 '"workspace"' "$CONFIG_FILE" | grep -oP '"path":\s*"\K[^"]+' | head -1)
+  GF_WORKSPACE_NAME=$(grep -A2 '"workspace"' "$CONFIG_FILE" | grep -oP '"name":\s*"\K[^"]+' | head -1)
+
   # Defaults for missing values
   GF_LANG=${GF_LANG:-en}
   GF_WORKTREE_MODE=${GF_WORKTREE_MODE:-organized}
@@ -130,6 +233,16 @@ read_gitflow_config() {
   GF_TAG_PREFIX=${GF_TAG_PREFIX:-v}
   GF_VERSION=${GF_VERSION:-0.1.0}
 
+  # Translate all stored paths to current platform format
+  # This ensures WSL paths are /mnt/d/... and Windows paths use forward slashes
+  GF_ROOT_FOLDER=$(normalize_path_for_platform "$GF_ROOT_FOLDER")
+  GF_MAIN_PATH=$(normalize_path_for_platform "$GF_MAIN_PATH")
+  GF_DEVELOP_PATH=$(normalize_path_for_platform "$GF_DEVELOP_PATH")
+  GF_FEATURES_PATH=$(normalize_path_for_platform "$GF_FEATURES_PATH")
+  GF_RELEASES_PATH=$(normalize_path_for_platform "$GF_RELEASES_PATH")
+  GF_HOTFIXES_PATH=$(normalize_path_for_platform "$GF_HOTFIXES_PATH")
+  [ -n "$GF_WORKSPACE_PATH" ] && GF_WORKSPACE_PATH=$(normalize_path_for_platform "$GF_WORKSPACE_PATH")
+
   # Export config file path for steps that need to update it
   GF_CONFIG_FILE="$CONFIG_FILE"
 }
@@ -201,6 +314,26 @@ cleanup_worktree_for_branch() {
 
 ---
 
+## RESOLVE_WORKSPACE
+
+Resolves the workspace JSON file by walking up the directory tree.
+
+```bash
+resolve_workspace_path() {
+  local dir="$(pwd)"
+  while [ "$dir" != "/" ] && [ "$dir" != "." ]; do
+    [ -f "$dir/.smartstack-workspace.json" ] && {
+      echo "$dir/.smartstack-workspace.json"
+      return 0
+    }
+    dir=$(dirname "$dir")
+  done
+  return 1
+}
+```
+
+---
+
 ## SYNC_REMOTE
 
 Syncs with remote and displays status.
@@ -221,11 +354,20 @@ sync_with_remote() {
 
 ## CONFIG_TEMPLATE
 
-GitFlow configuration JSON template v2.0.0 (aligned with `templates/config.json`).
+GitFlow configuration JSON template v2.1.0 (aligned with `templates/config.json`).
 
 ```json
 {
-  "version": "2.0.0",
+  "version": "2.1.0",
+  "platform": {
+    "detected": "",
+    "shell": "",
+    "detectedAt": ""
+  },
+  "workspace": {
+    "path": "",
+    "name": ""
+  },
   "repository": {
     "name": "",
     "rootFolder": "",

package/templates/skills/gitflow/phases/status.md

@@ -16,12 +16,18 @@ Display complete GitFlow state including branches, worktrees, remotes, and pendi
 ### 1. Load Config and Repository Info
 
 ```bash
-# Load GitFlow config (sets GF_* variables)
+# Detect platform first (needed for path translation)
+detect_platform
+
+# Load GitFlow config (sets GF_* variables, translates paths for current platform)
 read_gitflow_config || { echo "❌ Run /gitflow init first."; exit 1; }
 
 REPO_NAME="$GF_PROJECT_NAME"
 CURRENT=$(git rev-parse --abbrev-ref HEAD)
 GIT_PROVIDER="$GF_PROVIDER"
+
+# Workspace info (v2.1.0+)
+WS_FILE=$(resolve_workspace_path 2>/dev/null)
 ```
 
 ### 2. Branch Status
@@ -99,7 +105,11 @@ fi
 ╠══════════════════════════════════════════════════════════════════╣
 ║  Repository: {REPO_NAME}                                          ║
 ║  Provider:   {GIT_PROVIDER}                                       ║
+║  Platform:   {GF_PLATFORM} ({GF_SHELL})                           ║
 ║  Current:    {CURRENT}                                            ║
+{if WS_FILE}
+║  Workspace:  {dirname(WS_FILE)}                                   ║
+{endif}
 ╠══════════════════════════════════════════════════════════════════╣
 
 ## Main Branches

package/templates/skills/gitflow/steps/step-commit.md

@@ -180,7 +180,7 @@ PROBLEM: {what was wrong}
 SOLUTION: {what was done}
 IMPACT: {benefit}
 
-Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 ```
 
 ### 6. Create Commit

package/templates/skills/gitflow/steps/step-init.md

@@ -36,6 +36,22 @@ Set up GitFlow configuration with bare repository, worktrees, and branches.
 ### 1. Detect Environment (for defaults only)
 
 ```bash
+# PLATFORM DETECTION (required for correct path handling on WSL/Windows/macOS/Linux)
+if [ -f /proc/version ] && grep -qi "microsoft\|wsl" /proc/version 2>/dev/null; then
+  GF_PLATFORM="wsl"; GF_SHELL="bash"
+elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "mingw"* ]] || [[ "$OSTYPE" == "cygwin" ]]; then
+  GF_PLATFORM="windows"; GF_SHELL="gitbash"
+elif [[ -n "$WINDIR" ]] || [[ -n "$SystemRoot" ]]; then
+  GF_PLATFORM="windows"; GF_SHELL="powershell"
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+  GF_PLATFORM="macos"; GF_SHELL="zsh"
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+  GF_PLATFORM="linux"; GF_SHELL="bash"
+else
+  GF_PLATFORM="unknown"; GF_SHELL="bash"
+fi
+echo "Platform: $GF_PLATFORM ($GF_SHELL)"
+
 # Check if we're in a git repository
 IS_GIT_REPO=$(git rev-parse --git-dir 2>/dev/null && echo "true" || echo "false")
 
@@ -405,54 +421,84 @@ AskUserQuestion:
 
 ### 8. Create Directory Structure
 
-**⛔ Create the COMPLETE structure:**
+**⛔ CRITICAL: Use ABSOLUTE PATHS for ALL operations. NEVER use `cd` (it does not persist between Bash calls).**
+**⛔ Use `git -C <path>` or `GIT_DIR=<path>` instead of `cd` + `git`.**
 
+**Path normalization for WSL:**
 ```bash
-cd "{ROOT_FOLDER}"
-
-# Create bare repository if not exists
-if [ ! -d ".bare" ]; then
-  git clone --bare "{REPO_URL}" .bare
-  # Configure bare repo for worktrees
-  cd .bare
-  git config core.bare false
-  git config core.worktree ..
-  cd ..
+# If on WSL, translate Windows paths to /mnt/ format
+# normalize_path_for_platform() from _shared.md handles this
+# Example: D:/projects/MyApp → /mnt/d/projects/MyApp
+PROJECT_BASE="{ROOT_FOLDER}"  # Must be already normalized for current platform
+```
+
+**⛔ Create the COMPLETE structure with absolute paths:**
+
+```bash
+PROJECT_BASE="{ROOT_FOLDER}"
+
+# Create subdirectories (absolute paths)
+mkdir -p "$PROJECT_BASE/features" "$PROJECT_BASE/releases" "$PROJECT_BASE/hotfixes"
+
+# Create bare repository if not exists (absolute path, no cd)
+if [ ! -d "$PROJECT_BASE/.bare" ]; then
+  git clone --bare "{REPO_URL}" "$PROJECT_BASE/.bare"
+
+  # Configure bare repo for worktrees (using git -C, no cd)
+  git -C "$PROJECT_BASE/.bare" config core.bare false
+  git -C "$PROJECT_BASE/.bare" config core.worktree ..
 fi
 
-# Create worktree directories
-mkdir -p features releases hotfixes
+# Create .git pseudo-file pointing to .bare
+echo "gitdir: ./.bare" > "$PROJECT_BASE/.git"
 
-# Organized mode: numbered main folders
+# Organized mode: numbered main folders (absolute paths, GIT_DIR instead of cd)
 if [ "$WORKTREE_MODE" = "organized" ]; then
-  # Create main worktree
-  [ ! -d "01-Main" ] && git worktree add 01-Main main
+  [ ! -d "$PROJECT_BASE/01-Main" ] && \
+    GIT_DIR="$PROJECT_BASE/.bare" git worktree add "$PROJECT_BASE/01-Main" main
 
-  # Create develop worktree
-  [ ! -d "02-Develop" ] && git worktree add 02-Develop develop
+  [ ! -d "$PROJECT_BASE/02-Develop" ] && \
+    GIT_DIR="$PROJECT_BASE/.bare" git worktree add "$PROJECT_BASE/02-Develop" develop
 fi
 
-# Simple mode: named folders
+# Simple mode: named folders (absolute paths)
 if [ "$WORKTREE_MODE" = "simple" ]; then
-  [ ! -d "main" ] && git worktree add main main
-  [ ! -d "develop" ] && git worktree add develop develop
+  [ ! -d "$PROJECT_BASE/main" ] && \
+    GIT_DIR="$PROJECT_BASE/.bare" git worktree add "$PROJECT_BASE/main" main
+
+  [ ! -d "$PROJECT_BASE/develop" ] && \
+    GIT_DIR="$PROJECT_BASE/.bare" git worktree add "$PROJECT_BASE/develop" develop
 fi
 
-# Create gitflow config directory (in develop worktree)
-DEVELOP_PATH=$([ "$WORKTREE_MODE" = "organized" ] && echo "02-Develop" || echo "develop")
-mkdir -p "$DEVELOP_PATH/.claude/gitflow/{plans,logs,cache,backup}"
+# Create gitflow config directory (absolute paths)
+DEVELOP_DIR=$([ "$WORKTREE_MODE" = "organized" ] && echo "02-Develop" || echo "develop")
+mkdir -p "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow/plans"
+mkdir -p "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow/logs"
+mkdir -p "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow/cache"
+mkdir -p "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow/backup"
 ```
 
 ### 9. Create Configuration
 
-**Write `.claude/gitflow/config.json` in develop worktree:**
+**Write `.claude/gitflow/config.json` in develop worktree.**
+
+**⛔ IMPORTANT: Store paths using `normalize_path_for_storage()` format (Windows-style: `D:/path/to/folder`).** The `read_gitflow_config()` in `_shared.md` translates them to platform format at read time. This ensures WSL and Windows can share the same config.
 
 ```json
 {
-  "version": "2.0.0",
+  "version": "2.1.0",
+  "platform": {
+    "detected": "{GF_PLATFORM}",
+    "shell": "{GF_SHELL}",
+    "detectedAt": "{ISO_DATE}"
+  },
+  "workspace": {
+    "path": "{WORKSPACE_DIR_STORAGE_FORMAT}",
+    "name": ""
+  },
   "repository": {
     "name": "{PROJECT_NAME}",
-    "rootFolder": "{ROOT_FOLDER}",
+    "rootFolder": "{ROOT_FOLDER_STORAGE_FORMAT}",
     "nameVariants": {
       "pascalCaseDot": "{PascalCase.Dot}",
       "pascalCase": "{PascalCase}",
@@ -479,11 +525,11 @@ mkdir -p "$DEVELOP_PATH/.claude/gitflow/{plans,logs,cache,backup}"
     "enabled": true,
     "mode": "{WORKTREE_MODE}",
     "structure": {
-      "main": "{ROOT_FOLDER}/01-Main",
-      "develop": "{ROOT_FOLDER}/02-Develop",
-      "features": "{ROOT_FOLDER}/features",
-      "releases": "{ROOT_FOLDER}/releases",
-      "hotfixes": "{ROOT_FOLDER}/hotfixes"
+      "main": "{ROOT_FOLDER_STORAGE_FORMAT}/01-Main",
+      "develop": "{ROOT_FOLDER_STORAGE_FORMAT}/02-Develop",
+      "features": "{ROOT_FOLDER_STORAGE_FORMAT}/features",
+      "releases": "{ROOT_FOLDER_STORAGE_FORMAT}/releases",
+      "hotfixes": "{ROOT_FOLDER_STORAGE_FORMAT}/hotfixes"
     }
   },
   "versioning": {
@@ -513,21 +559,60 @@ mkdir -p "$DEVELOP_PATH/.claude/gitflow/{plans,logs,cache,backup}"
 }
 ```
 
+**Path storage convention:**
+- `{ROOT_FOLDER_STORAGE_FORMAT}` = result of `normalize_path_for_storage("{ROOT_FOLDER}")`
+- On WSL: `/mnt/d/projects/MyApp` → stored as `D:/projects/MyApp`
+- On Windows: `D:\projects\MyApp` → stored as `D:/projects/MyApp`
+- On Linux/macOS: `/home/user/projects/MyApp` → stored as-is
+
 ### 10. Detect Version
 
+**⛔ Use absolute paths with `git -C`, no `cd`.**
+
 ```bash
-# In develop worktree
-cd "$DEVELOP_PATH"
+DEVELOP_FULL_PATH="$PROJECT_BASE/$DEVELOP_DIR"
 
 # Priority: csproj > Directory.Build.props > package.json > VERSION > tag
-VERSION=$(grep -oP '<Version>\K[^<]+' *.csproj 2>/dev/null | head -1)
-[ -z "$VERSION" ] && VERSION=$(grep -oP '<Version>\K[^<]+' Directory.Build.props 2>/dev/null)
-[ -z "$VERSION" ] && VERSION=$(grep -oP '"version":\s*"\K[^"]+' package.json 2>/dev/null)
-[ -z "$VERSION" ] && VERSION=$(cat VERSION 2>/dev/null)
-[ -z "$VERSION" ] && VERSION=$(git describe --tags --abbrev=0 2>/dev/null | sed 's/^v//')
+VERSION=$(grep -oP '<Version>\K[^<]+' "$DEVELOP_FULL_PATH"/*.csproj 2>/dev/null | head -1)
+[ -z "$VERSION" ] && VERSION=$(grep -oP '<Version>\K[^<]+' "$DEVELOP_FULL_PATH/Directory.Build.props" 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(grep -oP '"version":\s*"\K[^"]+' "$DEVELOP_FULL_PATH/package.json" 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(cat "$DEVELOP_FULL_PATH/VERSION" 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(git -C "$DEVELOP_FULL_PATH" describe --tags --abbrev=0 2>/dev/null | sed 's/^v//')
 [ -z "$VERSION" ] && VERSION="0.1.0"
 ```
 
+### 10b. Post-Init Validation
+
+**⛔ MANDATORY: Verify the structure was created correctly.**
+
+```bash
+PROJECT_BASE="{ROOT_FOLDER}"
+MAIN_DIR=$([ "$WORKTREE_MODE" = "organized" ] && echo "01-Main" || echo "main")
+DEVELOP_DIR=$([ "$WORKTREE_MODE" = "organized" ] && echo "02-Develop" || echo "develop")
+ERRORS=0
+
+# Verify bare repo
+[ -f "$PROJECT_BASE/.bare/HEAD" ] && echo "✓ .bare/HEAD OK" || { echo "❌ .bare/HEAD missing"; ERRORS=$((ERRORS+1)); }
+
+# Verify worktrees on correct branches
+MAIN_BRANCH=$(git -C "$PROJECT_BASE/$MAIN_DIR" branch --show-current 2>/dev/null)
+[ "$MAIN_BRANCH" = "main" ] && echo "✓ $MAIN_DIR on main" || { echo "❌ $MAIN_DIR on '$MAIN_BRANCH', expected 'main'"; ERRORS=$((ERRORS+1)); }
+
+DEVELOP_BRANCH=$(git -C "$PROJECT_BASE/$DEVELOP_DIR" branch --show-current 2>/dev/null)
+[ "$DEVELOP_BRANCH" = "develop" ] && echo "✓ $DEVELOP_DIR on develop" || { echo "❌ $DEVELOP_DIR on '$DEVELOP_BRANCH', expected 'develop'"; ERRORS=$((ERRORS+1)); }
+
+# Verify directories
+for subdir in features releases hotfixes; do
+  [ -d "$PROJECT_BASE/$subdir" ] && echo "✓ $subdir/ OK" || { echo "❌ $subdir/ missing"; ERRORS=$((ERRORS+1)); }
+done
+
+# Verify config directory
+[ -d "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow" ] && echo "✓ .claude/gitflow/ OK" || { echo "❌ .claude/gitflow/ missing"; ERRORS=$((ERRORS+1)); }
+
+echo ""
+[ "$ERRORS" -eq 0 ] && echo "VALIDATION: ALL CHECKS PASSED" || echo "VALIDATION: $ERRORS error(s) detected - check output above"
+```
+
 ### 11. Summary
 
 ```
@@ -538,7 +623,9 @@ VERSION=$(grep -oP '<Version>\K[^<]+' *.csproj 2>/dev/null | head -1)
 ║  Root:       {ROOT_FOLDER}                                        ║
 ║  Remote:     {REPO_URL}                                           ║
 ║  Provider:   {GIT_PROVIDER}                                       ║
+║  Platform:   {GF_PLATFORM} ({GF_SHELL})                           ║
 ║  Version:    {VERSION}                                            ║
+║  Config:     v2.1.0                                               ║
 ╠══════════════════════════════════════════════════════════════════╣
 ║  Structure:                                                        ║
 ║  ├── .bare/           (git bare repository)                       ║
@@ -548,6 +635,8 @@ VERSION=$(grep -oP '<Version>\K[^<]+' *.csproj 2>/dev/null | head -1)
 ║  ├── releases/        (release worktrees)   ✅                    ║
 ║  └── hotfixes/        (hotfix worktrees)    ✅                    ║
 ╠══════════════════════════════════════════════════════════════════╣
+║  Validation: {ERRORS == 0 ? "ALL CHECKS PASSED" : "errors"}      ║
+╠══════════════════════════════════════════════════════════════════╣
 {if SIBLING_PROJECTS not empty}
 ║  Workspace: {WORKSPACE_DIR}                                       ║
 ║  GitFlow projects: {#SIBLING_PROJECTS + 1} (including this one)   ║
@@ -598,3 +687,77 @@ Before completing init, verify:
 ## NEXT STEP:
 
 Init is standalone. User should `cd 02-Develop` then run `/gitflow -f <feature-name>`.
+
+---
+
+## WORKSPACE MODE (`--workspace`)
+
+When called with `init --workspace`, batch-initialize all repos in a workspace.
+
+### Workspace Execution Sequence:
+
+1. **Ask workspace directory:**
+```yaml
+AskUserQuestion:
+  - header: "Workspace"
+    question: "Where is the workspace root? (parent directory containing all repos)"
+    options:
+      - label: "Use parent folder (Recommended)"
+        description: "{DETECTED_FOLDER}/"
+      - label: "Custom path"
+        description: "Specify a different location"
+    multiSelect: false
+```
+
+2. **Detect or ask for repos:**
+```yaml
+AskUserQuestion:
+  - header: "Repos"
+    question: "How to identify repositories to initialize?"
+    options:
+      - label: "Detect from folders (Recommended)"
+        description: "Scan workspace for git repositories"
+      - label: "Enter URLs"
+        description: "Provide a list of repository URLs"
+    multiSelect: false
+```
+
+3. **Create `.smartstack-workspace.json`:**
+```json
+{
+  "version": "1.0.0",
+  "name": "{WORKSPACE_NAME}",
+  "createdAt": "{ISO_DATE}",
+  "updatedAt": "{ISO_DATE}",
+  "platform": {
+    "detected": "{GF_PLATFORM}",
+    "shell": "{GF_SHELL}"
+  },
+  "repositories": [],
+  "defaults": {
+    "provider": "{GIT_PROVIDER}",
+    "worktreeMode": "organized",
+    "language": "en"
+  }
+}
+```
+
+4. **Loop: For each repo, run Steps 1-10b with workspace defaults pre-populated.**
+   - Skip questions where workspace defaults apply (provider, worktree mode)
+   - Add each repo to `workspace.json` after successful init
+
+5. **Display global summary:**
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                 WORKSPACE INITIALIZED                            ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Workspace: {WORKSPACE_DIR}                                      ║
+║  Platform:  {GF_PLATFORM} ({GF_SHELL})                           ║
+║  Repos:     {REPO_COUNT} initialized                             ║
+╠══════════════════════════════════════════════════════════════════╣
+{for each REPO}
+║  ✅ {REPO_NAME}                                                  ║
+║     01-Main/ ✓  02-Develop/ ✓  config.json ✓                     ║
+{end for}
+╚══════════════════════════════════════════════════════════════════╝
+```

package/templates/skills/gitflow/steps/step-pr.md

@@ -38,13 +38,25 @@ fi
 
 ```bash
 CURRENT=$(git rev-parse --abbrev-ref HEAD)
+BRANCH_TYPE=$(echo $CURRENT | cut -d'/' -f1)
+
+# CRITICAL: Verify config was loaded
+if [ -z "$GF_MAIN_BRANCH" ] || [ -z "$GF_DEVELOP_BRANCH" ]; then
+  echo "❌ GitFlow config not loaded properly"
+  echo "→ Variables GF_MAIN_BRANCH and GF_DEVELOP_BRANCH are empty"
+  exit 1
+fi
 
-case "$CURRENT" in
-  ${GF_FEATURE_PREFIX}*) TARGET_BRANCH="$GF_DEVELOP_BRANCH" ;;
-  ${GF_RELEASE_PREFIX}*) TARGET_BRANCH="$GF_MAIN_BRANCH" ;;
-  ${GF_HOTFIX_PREFIX}*)  TARGET_BRANCH="$GF_MAIN_BRANCH" ;;
-  *)                     TARGET_BRANCH="$GF_DEVELOP_BRANCH" ;;
+# Determine target branch based on type (using config values)
+case "$BRANCH_TYPE" in
+  feature) TARGET_BRANCH="$GF_DEVELOP_BRANCH" ;;
+  release) TARGET_BRANCH="$GF_MAIN_BRANCH" ;;
+  hotfix)  TARGET_BRANCH="$GF_MAIN_BRANCH" ;;
+  *)       TARGET_BRANCH="$GF_DEVELOP_BRANCH" ;;
 esac
+
+echo "✓ Branch: $CURRENT (type: $BRANCH_TYPE)"
+echo "✓ Target: $TARGET_BRANCH"
 ```
 
 ### 3. Check Prerequisites

package/templates/skills/gitflow/templates/config.json

@@ -1,5 +1,14 @@
 {
-  "version": "2.0.0",
+  "version": "2.1.0",
+  "platform": {
+    "detected": "",
+    "shell": "",
+    "detectedAt": ""
+  },
+  "workspace": {
+    "path": "",
+    "name": ""
+  },
   "repository": {
     "name": "",
     "rootFolder": "",

package/templates/skills/ralph-loop/SKILL.md

@@ -109,22 +109,27 @@ The loop only stops when this exact tag is output or max iterations reached.
 
 <workflow>
 **Standard flow (single module):**
-1. Parse flags and task description
-2. Verify MCP servers are available (MANDATORY)
-3. Initialize .ralph/ structure and state files
-4. Load current task from prd.json (or create initial task breakdown with categories, dependencies, and acceptance criteria)
-5. Execute ONE task per iteration
-6. Commit changes, update progress
-7. Check completion criteria
-8. If complete: generate final report
+1. Parse flags and task description (step-00)
+2. Verify MCP servers are available (step-00, MANDATORY)
+3. Initialize .ralph/ structure and state files (step-00)
+4. Load current task from prd.json — create task breakdown if new (step-01, READ ONCE)
+5. Execute first task (step-02, READ ONCE)
+6. Commit changes, update progress (step-03, READ ONCE)
+7. Check completion → enter COMPACT LOOP (step-04)
+8. **COMPACT LOOP** (step-04 section 5, NO re-reading step files):
+   - Find eligible tasks → batch by category (max 5)
+   - Execute batch inline
+   - Commit batch
+   - Re-check completion → loop or finish
+9. When complete: generate final report (step-05)
 
 **Multi-module flow (from BA handoff):**
 1-3. Same as standard flow
 4. Detect `prd-*.json` files → create `modules-queue.json`
 5. Copy current module's prd to `prd.json`
-6. Execute all tasks for current module (standard loop: steps 01→02→03→04)
-7. When module complete: advance to next module in queue
-8. Repeat steps 5-7 for each module
+6. Execute all tasks for current module via COMPACT LOOP
+7. When module complete: advance to next module in queue (step-04 section 3)
+8. Repeat steps 5-7 for each module (step-01 is re-read ONLY for module transitions)
 9. When all modules done: generate cross-module report
 </workflow>
 
@@ -279,12 +284,14 @@ Before ANY work, verify MCP servers:
 
 <execution_rules>
 
-- **Load one step at a time** - Only load the current step file
-- **VERIFY MCP FIRST** - Never skip MCP validation
-- **ONE TASK PER ITERATION** - Don't batch tasks
-- **COMMIT AFTER EACH TASK** - Atomic progress
+- **Load step files ONCE** - Step files are read only on FIRST iteration. After that, use the COMPACT LOOP in step-04 section 5.
+- **VERIFY MCP FIRST** - Never skip MCP validation at init
+- **BATCH same-category tasks** - Execute up to 5 tasks of the same category per iteration (reduces loop iterations from 30+ to ~8)
+- **COMMIT AFTER EACH BATCH** - One commit per batch, not per individual task
 - **UPDATE progress.txt** - Persist learnings
 - **NEVER fake completion** - Only output promise when truly done
+- **NEVER STOP THE LOOP** - The loop is AUTONOMOUS. DO NOT pause between iterations. DO NOT wait for user input. Only stop on: completion, max iterations, dead-end, or explicit user interruption. Stopping for any other reason wastes context and causes re-reads.
+- **COMPACT OUTPUT** - During loop iterations, use 1-2 lines per task. Save verbose output for the final report.
 </execution_rules>
 
 <success_criteria>