@atlashub/smartstack-cli 2.9.0 → 3.0.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/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/steps/step-03-commit.md

@@ -44,7 +44,7 @@ Task {current_task_id}/{tasks_total} - Iteration {current_iteration}
 Category: {current_task_category}
 {current_module ? "Module: " + current_module : ""}
 
-Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 EOF
 )"
 ```
@@ -189,7 +189,7 @@ Iteration {current_iteration} complete
 Status: {task.status}
 {current_module ? "Module: " + current_module : ""}
 
-Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 EOF
 )"
 ```

package/templates/skills/validate-feature/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: validate-feature
+description: Validate that a scaffolded feature works end-to-end (compile, test, API smoke test)
+version: 1.0.0
+author: SmartStack
+tags: [testing, validation, smoke-test, integration]
+---
+
+# /validate-feature
+
+## PURPOSE
+
+Validates that a scaffolded SmartStack feature **actually works** by running:
+1. Compilation check (`dotnet build`)
+2. Unit tests (`dotnet test`)
+3. Integration tests (`dotnet test --filter`)
+4. API smoke test (start API, hit CRUD endpoints, verify responses)
+
+## WHEN TO USE
+
+- After running `/application` to scaffold a new feature
+- After making changes to backend code (controllers, services, entities)
+- Before committing to verify nothing is broken
+- As a confidence check that the full stack works
+
+## USAGE
+
+```
+/validate-feature {EntityName}
+```
+
+**Examples:**
+```
+/validate-feature Product
+/validate-feature Order
+/validate-feature UserProfile
+```
+
+## PARAMETERS
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `{entity_name}` | YES | PascalCase entity name to validate |
+
+## PREREQUISITES
+
+- The solution must compile
+- Test project must exist with infrastructure (SmartStackTestFactory, IntegrationTestBase)
+- Entity must have been scaffolded (controller, service, entity files exist)
+
+## EXECUTION
+
+This skill follows a 4-step sequential workflow:
+
+| Step | File | Description | Blocking |
+|------|------|-------------|----------|
+| 1 | `steps/step-01-compile.md` | Build the full solution | YES |
+| 2 | `steps/step-02-unit-tests.md` | Run unit tests | YES |
+| 3 | `steps/step-03-integration-tests.md` | Run integration tests | YES |
+| 4 | `steps/step-04-api-smoke.md` | Start API and test CRUD endpoints | YES |
+
+Each step must PASS before proceeding to the next.
+
+## OUTPUT
+
+A validation report showing pass/fail for each check:
+
+```
+## Feature Validation: {EntityName}
+
+| Check | Result |
+|-------|--------|
+| Solution build | PASS |
+| Unit tests (X passed) | PASS |
+| Integration tests (X passed) | PASS |
+| API smoke: GET /api/{entity} | PASS (200) |
+| API smoke: POST /api/{entity} | PASS (201) |
+| API smoke: GET /api/{entity}/{id} | PASS (200) |
+| API smoke: PUT /api/{entity}/{id} | PASS (200) |
+| API smoke: DELETE /api/{entity}/{id} | PASS (204) |
+
+Result: ALL CHECKS PASSED
+```