@revotools/cli 0.5.0 → 0.6.1

package/dist/revo

@@ -8,7 +8,7 @@ set -euo pipefail
 # Exit cleanly on SIGPIPE (e.g., revo clone | grep, revo status | head)
 trap 'exit 0' PIPE
 
-REVO_VERSION="0.5.0"
+REVO_VERSION="0.6.1"
 
 
 # === lib/ui.sh ===
@@ -481,6 +481,7 @@ YAML_REPO_URLS=()
 YAML_REPO_PATHS=()
 YAML_REPO_TAGS=()
 YAML_REPO_DEPS=()
+YAML_REPO_BRANCHES=()
 
 yaml_parse() {
     local file="$1"
@@ -497,6 +498,7 @@ yaml_parse() {
     YAML_REPO_PATHS=()
     YAML_REPO_TAGS=()
     YAML_REPO_DEPS=()
+    YAML_REPO_BRANCHES=()
 
     if [[ ! -f "$file" ]]; then
         return 1
@@ -550,6 +552,7 @@ yaml_parse() {
                 YAML_REPO_PATHS[$current_index]=$(yaml_path_from_url "$url")
                 YAML_REPO_TAGS[$current_index]=""
                 YAML_REPO_DEPS[$current_index]=""
+                YAML_REPO_BRANCHES[$current_index]=""
                 YAML_REPO_COUNT=$((YAML_REPO_COUNT + 1))
                 continue
             fi
@@ -573,6 +576,8 @@ yaml_parse() {
                     deps_str="${deps_str//\"/}"
                     deps_str="${deps_str//\'/}"
                     YAML_REPO_DEPS[$current_index]="$deps_str"
+                elif [[ "$trimmed" =~ ^branch:[[:space:]]*(.+)$ ]]; then
+                    YAML_REPO_BRANCHES[$current_index]="${BASH_REMATCH[1]}"
                 fi
             fi
         fi
@@ -648,6 +653,12 @@ yaml_get_deps() {
     printf '%s' "${YAML_REPO_DEPS[$idx]:-}"
 }
 
+# Get repo default branch by index (empty means use workspace default)
+yaml_get_branch() {
+    local idx="$1"
+    printf '%s' "${YAML_REPO_BRANCHES[$idx]:-}"
+}
+
 # Find repo index by name (path basename)
 # Usage: idx=$(yaml_find_by_name "backend")
 # Returns: index or -1 if not found
@@ -681,6 +692,7 @@ yaml_write() {
             local path="${YAML_REPO_PATHS[$i]}"
             local tags="${YAML_REPO_TAGS[$i]}"
             local deps="${YAML_REPO_DEPS[$i]:-}"
+            local branch="${YAML_REPO_BRANCHES[$i]:-}"
 
             printf '  - url: %s\n' "$url"
 
@@ -700,6 +712,11 @@ yaml_write() {
             if [[ -n "$deps" ]]; then
                 printf '    depends_on: [%s]\n' "$deps"
             fi
+
+            # Write branch if it differs from the workspace default
+            if [[ -n "$branch" ]] && [[ "$branch" != "$YAML_DEFAULTS_BRANCH" ]]; then
+                printf '    branch: %s\n' "$branch"
+            fi
         done
 
         printf '\ndefaults:\n'
@@ -708,12 +725,13 @@ yaml_write() {
 }
 
 # Add a repo to the config
-# Usage: yaml_add_repo "url" "path" "tags" "deps"
+# Usage: yaml_add_repo "url" "path" "tags" "deps" ["branch"]
 yaml_add_repo() {
     local url="$1"
     local path="${2:-}"
     local tags="${3:-}"
     local deps="${4:-}"
+    local branch="${5:-}"
 
     local idx=$YAML_REPO_COUNT
 
@@ -725,6 +743,7 @@ yaml_add_repo() {
     YAML_REPO_PATHS[$idx]="$path"
     YAML_REPO_TAGS[$idx]="$tags"
     YAML_REPO_DEPS[$idx]="$deps"
+    YAML_REPO_BRANCHES[$idx]="$branch"
 
     YAML_REPO_COUNT=$((YAML_REPO_COUNT + 1))
 }
@@ -736,6 +755,12 @@ yaml_add_repo() {
 REVO_WORKSPACE_ROOT=""
 REVO_CONFIG_FILE=""
 REVO_REPOS_DIR=""
+# When invoked from inside .revo/workspaces/<name>/, REVO_REPOS_DIR is
+# overridden to point at that workspace dir so existing commands (status,
+# commit, push, pr, exec, ...) operate on the workspace's copies of the
+# repos rather than the source tree under repos/. REVO_ACTIVE_WORKSPACE
+# holds the workspace name in that case (empty otherwise).
+REVO_ACTIVE_WORKSPACE=""
 
 # Find workspace root by searching upward for revo.yaml (or mars.yaml as fallback)
 # Usage: config_find_root [start_dir]
@@ -749,6 +774,7 @@ config_find_root() {
             REVO_WORKSPACE_ROOT="$current"
             REVO_CONFIG_FILE="$current/revo.yaml"
             REVO_REPOS_DIR="$current/repos"
+            _config_apply_workspace_override "$start_dir"
             return 0
         fi
         # Fallback: support mars.yaml for migration from Mars
@@ -756,6 +782,7 @@ config_find_root() {
             REVO_WORKSPACE_ROOT="$current"
             REVO_CONFIG_FILE="$current/mars.yaml"
             REVO_REPOS_DIR="$current/repos"
+            _config_apply_workspace_override "$start_dir"
             return 0
         fi
         current="$(dirname "$current")"
@@ -764,6 +791,37 @@ config_find_root() {
     return 1
 }
 
+# If start_dir is inside .revo/workspaces/<name>/, point REVO_REPOS_DIR at
+# that workspace and remember the active workspace name. Otherwise leave
+# things alone. Called from config_find_root after the root has been set.
+_config_apply_workspace_override() {
+    local start_dir="$1"
+    REVO_ACTIVE_WORKSPACE=""
+
+    [[ -z "$REVO_WORKSPACE_ROOT" ]] && return 0
+
+    local prefix="$REVO_WORKSPACE_ROOT/.revo/workspaces/"
+    case "$start_dir/" in
+        "$prefix"*)
+            local rest="${start_dir#"$prefix"}"
+            local ws_name="${rest%%/*}"
+            if [[ -n "$ws_name" ]] && [[ -d "$prefix$ws_name" ]]; then
+                REVO_REPOS_DIR="$prefix$ws_name"
+                REVO_ACTIVE_WORKSPACE="$ws_name"
+            fi
+            ;;
+    esac
+    return 0
+}
+
+# Always returns the source repos dir ($REVO_WORKSPACE_ROOT/repos),
+# regardless of any active workspace override. Used by `revo workspace`
+# itself, which must read from the source tree even when invoked from
+# inside another workspace.
+config_source_repos_dir() {
+    printf '%s/repos' "$REVO_WORKSPACE_ROOT"
+}
+
 # Initialize workspace in current directory
 # Usage: config_init "workspace_name"
 # Returns: 0 on success, 1 if already initialized
@@ -787,6 +845,7 @@ config_init() {
     YAML_REPO_PATHS=()
     YAML_REPO_TAGS=()
     YAML_REPO_DEPS=()
+    YAML_REPO_BRANCHES=()
 
     # Create directory structure
     mkdir -p "$REVO_REPOS_DIR"
@@ -928,11 +987,25 @@ config_workspace_name() {
     printf '%s' "$YAML_WORKSPACE_NAME"
 }
 
-# Get default branch
+# Get workspace default branch
 config_default_branch() {
     printf '%s' "$YAML_DEFAULTS_BRANCH"
 }
 
+# Get effective default branch for a specific repo
+# Falls back to workspace default if no per-repo branch is set
+# Usage: branch=$(config_repo_default_branch "repo_index")
+config_repo_default_branch() {
+    local idx="$1"
+    local branch
+    branch=$(yaml_get_branch "$idx")
+    if [[ -n "$branch" ]]; then
+        printf '%s' "$branch"
+    else
+        printf '%s' "$YAML_DEFAULTS_BRANCH"
+    fi
+}
+
 # === lib/git.sh ===
 # Revo CLI - Git Operations
 # Wrapper functions for git commands with consistent error handling
@@ -1141,6 +1214,34 @@ git_remote_url() {
     git -C "$repo_dir" remote get-url origin 2>/dev/null
 }
 
+# Detect the default branch for a cloned repo
+# Tries symbolic-ref first, then falls back to checking main/master
+# Usage: branch=$(git_default_branch "repo_dir")
+git_default_branch() {
+    local repo_dir="$1"
+    local ref
+
+    # Best source: what the remote says HEAD points to
+    ref=$(git -C "$repo_dir" symbolic-ref refs/remotes/origin/HEAD 2>/dev/null)
+    if [[ -n "$ref" ]]; then
+        printf '%s' "${ref##*/}"
+        return 0
+    fi
+
+    # Fallback: check which of main/master exists
+    if git -C "$repo_dir" rev-parse --verify origin/main >/dev/null 2>&1; then
+        printf '%s' "main"
+        return 0
+    fi
+    if git -C "$repo_dir" rev-parse --verify origin/master >/dev/null 2>&1; then
+        printf '%s' "master"
+        return 0
+    fi
+
+    # Last resort: whatever branch we're on
+    git -C "$repo_dir" rev-parse --abbrev-ref HEAD 2>/dev/null
+}
+
 # Check if branch exists (local or remote)
 # Usage: if git_branch_exists "repo_dir" "branch_name"; then ...
 git_branch_exists() {
@@ -1694,8 +1795,10 @@ cmd_init() {
             fi
 
             tags=$(_init_auto_tags "$dir" "$name")
-            yaml_add_repo "$remote" "$path" "$tags" ""
-            ui_step_done "Detected:" "$name → $remote"
+            local branch
+            branch=$(git_default_branch "$dir")
+            yaml_add_repo "$remote" "$path" "$tags" "" "$branch"
+            ui_step_done "Detected:" "$name → $remote (branch: $branch)"
             detected_count=$((detected_count + 1))
         done <<< "$_INIT_FOUND_DIRS"
 
@@ -1800,8 +1903,10 @@ cmd_detect() {
             ln -s "../$name" "repos/$name"
         fi
 
-        yaml_add_repo "$remote" "$name" "$tags" ""
-        ui_step_done "Found:" "$name ($remote)"
+        local branch
+        branch=$(git_default_branch "$d")
+        yaml_add_repo "$remote" "$name" "$tags" "" "$branch"
+        ui_step_done "Found:" "$name ($remote, branch: $branch)"
         found=$((found + 1))
     done
 
@@ -1821,8 +1926,10 @@ cmd_detect() {
             done
             [[ $already -eq 1 ]] && continue
             remote=$(cd "$d" && git remote get-url origin 2>/dev/null || echo "local://$d")
-            yaml_add_repo "$remote" "$name" "$name" ""
-            ui_step_done "Found:" "$name ($remote)"
+            local branch
+            branch=$(git_default_branch "$d")
+            yaml_add_repo "$remote" "$name" "$name" "" "$branch"
+            ui_step_done "Found:" "$name ($remote, branch: $branch)"
             found=$((found + 1))
         done
     fi
@@ -1927,7 +2034,13 @@ cmd_clone() {
         local clone_err
         if clone_err=$(git clone --quiet "$url" "$full_path" 2>&1); then
             ui_spinner_stop
-            ui_step_done "Cloned:" "$path"
+            # Detect and store the repo's default branch
+            local detected_branch
+            detected_branch=$(git_default_branch "$full_path")
+            if [[ -n "$detected_branch" ]]; then
+                YAML_REPO_BRANCHES[$repo]="$detected_branch"
+            fi
+            ui_step_done "Cloned:" "$path (branch: ${detected_branch:-$YAML_DEFAULTS_BRANCH})"
             success_count=$((success_count + 1))
         else
             ui_spinner_error "Failed to clone: $path"
@@ -1938,9 +2051,12 @@ cmd_clone() {
         fi
     done <<< "$repos"
 
-    # Always regenerate the workspace CLAUDE.md after a clone batch so that
-    # newly cloned repos appear in the context immediately.
+    # Persist any newly detected per-repo branches and regenerate CLAUDE.md
+    # so newly cloned repos appear in the context immediately.
     if [[ $fail_count -eq 0 ]] && { [[ $success_count -gt 0 ]] || [[ $skip_count -gt 0 ]]; }; then
+        if [[ $success_count -gt 0 ]]; then
+            config_save
+        fi
         context_regenerate_silent
     fi
 
@@ -2229,6 +2345,12 @@ cmd_checkout() {
             continue
         fi
 
+        # Resolve "default" to each repo's own default branch
+        local target="$branch_name"
+        if [[ "$target" == "default" ]]; then
+            target=$(config_repo_default_branch "$repo")
+        fi
+
         # Check for uncommitted changes
         if git_is_dirty "$full_path" && [[ $force -eq 0 ]]; then
             ui_step_error "Uncommitted changes: $path"
@@ -2238,15 +2360,15 @@ cmd_checkout() {
         fi
 
         # Check if branch exists
-        if ! git_branch_exists "$full_path" "$branch_name"; then
-            ui_step_error "Branch not found: $path"
+        if ! git_branch_exists "$full_path" "$target"; then
+            ui_step_error "Branch not found: $path ($target)"
             fail_count=$((fail_count + 1))
             continue
         fi
 
         # Checkout
-        if git_checkout "$full_path" "$branch_name"; then
-            ui_step_done "Checked out:" "$path → $branch_name"
+        if git_checkout "$full_path" "$target"; then
+            ui_step_done "Checked out:" "$path → $target"
             success_count=$((success_count + 1))
         else
             ui_step_error "Failed: $path - $GIT_ERROR"
@@ -2860,6 +2982,17 @@ _context_write_file() {
         url=$(yaml_get_url "$i")
         full_path="$REVO_REPOS_DIR/$path"
 
+        local branch
+        branch=$(yaml_get_branch "$i")
+
+        # Backfill: detect default branch for cloned repos that don't have one stored
+        if [[ -z "$branch" ]] && [[ -d "$full_path" ]]; then
+            branch=$(git_default_branch "$full_path")
+            if [[ -n "$branch" ]]; then
+                YAML_REPO_BRANCHES[$i]="$branch"
+            fi
+        fi
+
         {
             printf '### %s\n' "$path"
 
@@ -2867,6 +3000,9 @@ _context_write_file() {
                 printf -- '- **Tags:** %s\n' "$tags"
             fi
             printf -- '- **Path:** repos/%s\n' "$path"
+            if [[ -n "$branch" ]] && [[ "$branch" != "$YAML_DEFAULTS_BRANCH" ]]; then
+                printf -- '- **Default branch:** %s\n' "$branch"
+            fi
             if [[ -n "$deps" ]]; then
                 printf -- '- **Depends on:** %s\n' "$deps"
             fi
@@ -2941,6 +3077,35 @@ _context_write_file() {
         printf '\n> Warning: a dependency cycle was detected. Listed in best-effort order.\n' >> "$output"
     fi
 
+    # Active workspaces (any .revo/workspaces/*/ dirs)
+    local workspaces_dir="$REVO_WORKSPACE_ROOT/.revo/workspaces"
+    if [[ -d "$workspaces_dir" ]]; then
+        local has_workspaces=0
+        local ws
+        for ws in "$workspaces_dir"/*/; do
+            [[ -d "$ws" ]] || continue
+            if [[ $has_workspaces -eq 0 ]]; then
+                {
+                    printf '\n'
+                    printf '## Active Workspaces\n'
+                    printf '\n'
+                } >> "$output"
+                has_workspaces=1
+            fi
+            local ws_name
+            ws_name=$(basename "$ws")
+            printf -- '- **%s** — `.revo/workspaces/%s/` (branch: feature/%s)\n' \
+                "$ws_name" "$ws_name" "$ws_name" >> "$output"
+        done
+        if [[ $has_workspaces -eq 1 ]]; then
+            {
+                printf '\n'
+                printf 'Run `revo workspaces` for branch/dirty status, or `cd` into one\n'
+                printf 'and run revo from there to operate on the workspace copy.\n'
+            } >> "$output"
+        fi
+    fi
+
     # Active features (any .revo/features/*.md files)
     local features_dir="$REVO_WORKSPACE_ROOT/.revo/features"
     if [[ -d "$features_dir" ]]; then
@@ -2978,6 +3143,8 @@ _context_write_file() {
         printf '6. Use `revo commit "msg"` to commit across all repos at once\n'
         printf '7. Use `revo feature <name>` to start a coordinated feature workspace\n'
         printf '8. Use `revo pr "title"` to open coordinated pull requests\n'
+        printf '9. Use `revo workspace <name>` to get a full-copy isolated workspace\n'
+        printf '   under `.revo/workspaces/<name>/` (zero bootstrap, .env included)\n'
         printf '\n'
         printf '## Workspace Tool: revo\n'
         printf '\n'
@@ -3002,6 +3169,17 @@ _context_write_file() {
         printf -- '- `revo exec "cmd" [--tag t]` — run command in filtered repos\n'
         printf -- '- `revo checkout <branch> [--tag t]` — switch branch across repos\n'
         printf '\n'
+        printf '**Workspaces (full-copy isolated workspaces):**\n'
+        printf -- '- `revo workspace <name> [--tag t]` — full copy of repos into `.revo/workspaces/<name>/` on `feature/<name>`\n'
+        printf -- '- `revo workspaces` — list active workspaces with branch and dirty state\n'
+        printf -- '- `revo workspace <name> --delete [--force]` — remove a workspace\n'
+        printf -- '- `revo workspace --clean` — remove workspaces whose branches are merged\n'
+        printf '\n'
+        printf 'Workspaces hardlink-copy everything (including `.env`, `node_modules`,\n'
+        printf 'build artifacts) so Claude can start work with zero bootstrap. Run\n'
+        printf '`revo` from inside `.revo/workspaces/<name>/` and it operates on the\n'
+        printf 'workspace copies, not the source tree.\n'
+        printf '\n'
         printf '**Issues (cross-repo, via gh CLI):**\n'
         printf -- '- `revo issue list [--tag t] [--state open|closed|all] [--label L] [--json]` — list issues across repos\n'
         printf -- '- `revo issue create --repo <name> "title" [--body b] [--label L] [--feature F]` — create in one repo\n'
@@ -3070,6 +3248,8 @@ cmd_context() {
 
     ui_spinner_start "Scanning $YAML_REPO_COUNT repositories..."
     _context_write_file "$output"
+    # Persist any newly detected per-repo branches back to revo.yaml
+    config_save
     ui_spinner_stop
     ui_step_done "Scanned:" "$YAML_REPO_COUNT repositories"
     ui_step_done "Wrote:" "CLAUDE.md"
@@ -3205,10 +3385,10 @@ cmd_feature() {
             printf '# Feature: %s\n' "$name"
             printf '\n'
             printf '## Status\n'
-            printf '- Created: %s\n' "$timestamp"
-            printf '- Branch: %s\n' "$branch"
+            printf -- '- Created: %s\n' "$timestamp"
+            printf -- '- Branch: %s\n' "$branch"
             if [[ -n "$tag" ]]; then
-                printf '- Tag filter: %s\n' "$tag"
+                printf -- '- Tag filter: %s\n' "$tag"
             fi
             printf '\n'
             printf '## Repos\n'
@@ -4094,6 +4274,648 @@ _issue_create() {
     fi
 }
 
+# === lib/commands/workspace.sh ===
+# Revo CLI - workspace / workspaces commands
+# Full-copy workspaces under .revo/workspaces/<name>/. Unlike git worktrees
+# these copy *everything* — .env, node_modules, build artifacts — so Claude
+# can start work immediately with zero bootstrap. Hardlinks are used where
+# possible so the cost is near-zero on APFS/HFS+ and Linux.
+
+# --- helpers ---
+
+# Sanitize a workspace name: lowercase, hyphens for spaces, drop anything
+# that isn't [a-z0-9_-]. Keeps the resulting name safe to use as both a
+# directory name and a git branch suffix.
+_workspace_sanitize_name() {
+    local raw="$1"
+    local lowered
+    lowered=$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]')
+    lowered=$(printf '%s' "$lowered" | tr ' ' '-')
+    # Replace anything not a-z0-9-_ with -
+    lowered=$(printf '%s' "$lowered" | sed 's/[^a-z0-9_-]/-/g')
+    # Collapse runs of - and trim leading/trailing -
+    lowered=$(printf '%s' "$lowered" | sed -e 's/--*/-/g' -e 's/^-//' -e 's/-$//')
+    printf '%s' "$lowered"
+}
+
+# Verify .revo/ is in the workspace .gitignore. Workspaces hardlink-copy
+# everything, including .env files, so this is a hard requirement to avoid
+# accidentally committing secrets via the parent git repo (if any).
+# Returns 0 if safe, 1 if .revo/ is not gitignored.
+_workspace_verify_gitignore_safe() {
+    local gitignore="$REVO_WORKSPACE_ROOT/.gitignore"
+
+    # If the workspace root isn't itself a git repo, there's nothing to
+    # accidentally commit into. Treat as safe.
+    if [[ ! -d "$REVO_WORKSPACE_ROOT/.git" ]]; then
+        return 0
+    fi
+
+    if [[ ! -f "$gitignore" ]]; then
+        return 1
+    fi
+
+    # Match `.revo/`, `.revo`, `/.revo/`, `/.revo` — any of those works
+    awk '
+        { sub(/^[[:space:]]+/, ""); sub(/[[:space:]]+$/, "") }
+        $0 == ".revo" || $0 == ".revo/" || $0 == "/.revo" || $0 == "/.revo/" { found = 1; exit }
+        END { exit !found }
+    ' "$gitignore"
+}
+
+# Copy a source repo into the workspace. Tries hardlinks first
+# (`cp -RLl`), falls back to a regular recursive copy. Always follows
+# symlinks so init-style symlinked repos are materialized as real
+# directories inside the workspace.
+# Usage: _workspace_copy_repo "src" "dest"
+# Returns: 0 on success
+_workspace_copy_repo() {
+    local src="$1"
+    local dest="$2"
+
+    # Make sure parent exists, dest does not
+    mkdir -p "$(dirname "$dest")"
+    rm -rf "$dest" 2>/dev/null
+
+    # Try hardlinks first. -R recursive, -L follow symlinks, -l hardlink.
+    if cp -RLl "$src" "$dest" 2>/dev/null; then
+        return 0
+    fi
+
+    # Fall back to a real copy
+    rm -rf "$dest" 2>/dev/null
+    if cp -RL "$src" "$dest" 2>/dev/null; then
+        return 0
+    fi
+
+    return 1
+}
+
+# Print mtime in seconds-since-epoch for a path. Handles BSD (macOS) and
+# GNU (Linux) stat. Prints 0 if both fail.
+_workspace_mtime() {
+    local path="$1"
+    local mtime
+    if mtime=$(stat -f %m "$path" 2>/dev/null); then
+        printf '%s' "$mtime"
+        return 0
+    fi
+    if mtime=$(stat -c %Y "$path" 2>/dev/null); then
+        printf '%s' "$mtime"
+        return 0
+    fi
+    printf '0'
+}
+
+# Format an age in seconds as a short, human string ("2h", "3d", ...).
+_workspace_format_age() {
+    local secs="$1"
+    if [[ -z "$secs" ]] || [[ "$secs" -le 0 ]]; then
+        printf 'just now'
+        return
+    fi
+    if [[ "$secs" -lt 60 ]]; then
+        printf '%ds' "$secs"
+    elif [[ "$secs" -lt 3600 ]]; then
+        printf '%dm' $((secs / 60))
+    elif [[ "$secs" -lt 86400 ]]; then
+        printf '%dh' $((secs / 3600))
+    else
+        printf '%dd' $((secs / 86400))
+    fi
+}
+
+# Iterate the immediate subdirectories of a workspace dir that look like
+# git repos. Prints one path per line.
+# Usage: _workspace_repo_dirs "/abs/.revo/workspaces/foo"
+_workspace_repo_dirs() {
+    local ws_dir="$1"
+    local d
+    for d in "$ws_dir"/*/; do
+        [[ -d "$d" ]] || continue
+        d="${d%/}"
+        if [[ -d "$d/.git" ]] || [[ -f "$d/.git" ]]; then
+            printf '%s\n' "$d"
+        fi
+    done
+}
+
+# Returns 0 if the workspace has any repo with unpushed commits or
+# uncommitted changes. Used by --delete to require --force.
+_workspace_has_local_work() {
+    local ws_dir="$1"
+    local d
+    while IFS= read -r d; do
+        [[ -z "$d" ]] && continue
+        # Dirty working tree?
+        if [[ -n "$(git -C "$d" status --porcelain 2>/dev/null)" ]]; then
+            return 0
+        fi
+        # Any commits not present on any remote ref?
+        local unpushed
+        unpushed=$(git -C "$d" log --oneline --not --remotes 2>/dev/null | head -n 1)
+        if [[ -n "$unpushed" ]]; then
+            return 0
+        fi
+    done <<< "$(_workspace_repo_dirs "$ws_dir")"
+    return 1
+}
+
+# Returns 0 if every repo in the workspace has its current branch merged
+# into the workspace default branch (local or origin/<default>).
+# Workspaces with no repo dirs are not considered merged.
+_workspace_all_merged() {
+    local ws_dir="$1"
+    local default_branch="$2"
+    local any=0
+    local d
+    while IFS= read -r d; do
+        [[ -z "$d" ]] && continue
+        any=1
+        # Try local default branch first, then origin/<default>
+        if git -C "$d" merge-base --is-ancestor HEAD "$default_branch" 2>/dev/null; then
+            continue
+        fi
+        if git -C "$d" merge-base --is-ancestor HEAD "origin/$default_branch" 2>/dev/null; then
+            continue
+        fi
+        return 1
+    done <<< "$(_workspace_repo_dirs "$ws_dir")"
+    [[ $any -eq 1 ]]
+}
+
+# Generate a workspace-specific CLAUDE.md inside the workspace dir. Kept
+# intentionally short — the root workspace CLAUDE.md is the canonical
+# reference; this one just orients the agent inside the isolated copy.
+_workspace_write_claude_md() {
+    local name="$1"
+    local ws_dir="$2"
+    local branch="$3"
+    local target="$ws_dir/CLAUDE.md"
+    local timestamp
+    timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    local parent_name
+    parent_name=$(config_workspace_name)
+
+    {
+        printf '# revo workspace: %s\n' "$name"
+        printf '\n'
+        printf '> WARNING: This workspace contains .env files and other secrets\n'
+        printf '> hardlinked from the source repos. Never commit the .revo/\n'
+        printf '> directory.\n'
+        printf '\n'
+        printf -- '- **Branch:** %s\n' "$branch"
+        printf -- '- **Created:** %s\n' "$timestamp"
+        if [[ -n "$parent_name" ]]; then
+            printf -- '- **Parent workspace:** %s\n' "$parent_name"
+        fi
+        printf -- '- **Source:** ../../repos/\n'
+        printf '\n'
+        printf 'This is an isolated full-copy workspace. All edits, commits,\n'
+        printf 'and pushes happen here — the source tree under `repos/` is\n'
+        printf 'untouched. When you run `revo` from inside this directory it\n'
+        printf 'automatically operates on the repos under this workspace, not\n'
+        printf 'the source ones.\n'
+        printf '\n'
+        printf '## Repos\n'
+        printf '\n'
+
+        local d
+        while IFS= read -r d; do
+            [[ -z "$d" ]] && continue
+            local rname rbranch
+            rname=$(basename "$d")
+            rbranch=$(git -C "$d" rev-parse --abbrev-ref HEAD 2>/dev/null || printf '?')
+            printf '### %s\n' "$rname"
+            printf -- '- **Path:** ./%s\n' "$rname"
+            printf -- '- **Branch:** %s\n' "$rbranch"
+
+            scan_repo "$d"
+            if [[ -n "$SCAN_LANG" ]]; then
+                if [[ -n "$SCAN_NAME" ]]; then
+                    printf -- '- **Package:** %s (%s)\n' "$SCAN_NAME" "$SCAN_LANG"
+                else
+                    printf -- '- **Language:** %s\n' "$SCAN_LANG"
+                fi
+            fi
+            if [[ -n "$SCAN_FRAMEWORK" ]]; then
+                printf -- '- **Framework:** %s\n' "$SCAN_FRAMEWORK"
+            fi
+            if [[ -n "$SCAN_ROUTES" ]]; then
+                printf -- '- **API routes:** %s\n' "$SCAN_ROUTES"
+            fi
+            printf '\n'
+        done <<< "$(_workspace_repo_dirs "$ws_dir")"
+
+        printf '## Workflow\n'
+        printf '\n'
+        printf '1. Edit code across the repos above\n'
+        printf '2. `revo commit "msg"` to commit dirty repos in one shot\n'
+        printf '3. `revo push` to push branches\n'
+        printf '4. `revo pr "title"` to open coordinated PRs\n'
+        printf '5. After merge, `cd ../../.. && revo workspace %s --delete`\n' "$name"
+        printf '\n'
+        printf '## Workspace Tool: revo\n'
+        printf '\n'
+        printf 'See ../../CLAUDE.md (the parent workspace context) for the full\n'
+        printf 'revo command reference, dependency order, and per-repo details.\n'
+    } > "$target"
+}
+
+# --- create ---
+
+_workspace_create() {
+    local name="$1"
+    local tag="$2"
+    local force="$3"
+
+    local sanitized
+    sanitized=$(_workspace_sanitize_name "$name")
+    if [[ -z "$sanitized" ]]; then
+        ui_step_error "Invalid workspace name: $name"
+        return 1
+    fi
+
+    if [[ "$sanitized" != "$name" ]]; then
+        ui_info "$(ui_dim "Sanitized name: $name -> $sanitized")"
+    fi
+    name="$sanitized"
+
+    local branch="feature/$name"
+    local ws_root="$REVO_WORKSPACE_ROOT/.revo/workspaces"
+    local ws_dir="$ws_root/$name"
+
+    ui_intro "Revo - Create Workspace: $name"
+
+    if [[ -d "$ws_dir" ]]; then
+        ui_step_error "Workspace already exists: .revo/workspaces/$name"
+        ui_info "$(ui_dim "Use 'revo workspace $name --delete' to remove it first")"
+        ui_outro_cancel "Aborted"
+        return 1
+    fi
+
+    if ! _workspace_verify_gitignore_safe; then
+        ui_step_error ".revo/ is not in .gitignore at the workspace root"
+        ui_info "$(ui_dim "Workspaces hardlink-copy .env files and secrets — committing")"
+        ui_info "$(ui_dim ".revo/ would leak them. Add '.revo/' to .gitignore (or run 'revo init').")"
+        if [[ $force -ne 1 ]]; then
+            ui_info "$(ui_dim "Re-run with --force to override.")"
+            ui_outro_cancel "Aborted for safety"
+            return 1
+        fi
+        ui_step_error "Continuing anyway because --force was passed"
+    fi
+
+    local source_repos_dir
+    source_repos_dir=$(config_source_repos_dir)
+
+    local repos
+    repos=$(config_get_repos "$tag")
+
+    if [[ -z "$repos" ]]; then
+        if [[ -n "$tag" ]]; then
+            ui_step_error "No repositories match tag: $tag"
+        else
+            ui_step_error "No repositories configured"
+        fi
+        ui_outro_cancel "Nothing to copy"
+        return 1
+    fi
+
+    mkdir -p "$ws_dir"
+
+    local success_count=0
+    local skip_count=0
+    local fail_count=0
+
+    while IFS= read -r repo; do
+        [[ -z "$repo" ]] && continue
+
+        local path
+        path=$(yaml_get_path "$repo")
+        local src="$source_repos_dir/$path"
+        local dest="$ws_dir/$path"
+
+        if [[ ! -d "$src" ]]; then
+            ui_step_done "Skipped (not cloned):" "$path"
+            skip_count=$((skip_count + 1))
+            continue
+        fi
+
+        ui_spinner_start "Copying $path..."
+        if _workspace_copy_repo "$src" "$dest"; then
+            ui_spinner_stop
+            ui_step_done "Copied:" "$path"
+        else
+            ui_spinner_error "Failed to copy: $path"
+            fail_count=$((fail_count + 1))
+            continue
+        fi
+
+        # Check out the workspace branch in the copy
+        if git -C "$dest" rev-parse --verify "$branch" >/dev/null 2>&1; then
+            if git -C "$dest" checkout "$branch" >/dev/null 2>&1; then
+                ui_step_done "Checked out existing:" "$path -> $branch"
+            else
+                ui_step_error "Failed to checkout existing branch in: $path"
+                fail_count=$((fail_count + 1))
+                continue
+            fi
+        else
+            if git -C "$dest" checkout -b "$branch" >/dev/null 2>&1; then
+                ui_step_done "Branched:" "$path -> $branch"
+            else
+                ui_step_error "Failed to create branch in: $path"
+                fail_count=$((fail_count + 1))
+                continue
+            fi
+        fi
+
+        success_count=$((success_count + 1))
+    done <<< "$repos"
+
+    if [[ $success_count -eq 0 ]]; then
+        ui_outro_cancel "No repos copied; workspace cleanup needed"
+        rm -rf "$ws_dir" 2>/dev/null
+        return 1
+    fi
+
+    # Workspace-level CLAUDE.md
+    _workspace_write_claude_md "$name" "$ws_dir" "$branch"
+    ui_step_done "Wrote:" "$ws_dir/CLAUDE.md"
+
+    ui_bar_line
+
+    if [[ $fail_count -gt 0 ]]; then
+        ui_outro_cancel "Created with errors: $success_count ok, $fail_count failed"
+        return 1
+    fi
+
+    local msg="Workspace ready at .revo/workspaces/$name/"
+    ui_info "$(ui_dim "Branch: $branch  •  Repos: $success_count")"
+    if [[ $skip_count -gt 0 ]]; then
+        ui_info "$(ui_dim "$skip_count repo(s) skipped (not cloned in source)")"
+    fi
+    ui_info "$(ui_dim "cd .revo/workspaces/$name and run revo from there.")"
+    ui_outro "$msg"
+    return 0
+}
+
+# --- delete ---
+
+_workspace_delete() {
+    local name="$1"
+    local force="$2"
+
+    local sanitized
+    sanitized=$(_workspace_sanitize_name "$name")
+    name="$sanitized"
+
+    local ws_dir="$REVO_WORKSPACE_ROOT/.revo/workspaces/$name"
+
+    ui_intro "Revo - Delete Workspace: $name"
+
+    if [[ ! -d "$ws_dir" ]]; then
+        ui_step_error "No such workspace: $name"
+        ui_outro_cancel "Nothing to delete"
+        return 1
+    fi
+
+    if [[ $force -ne 1 ]] && _workspace_has_local_work "$ws_dir"; then
+        ui_step_error "Workspace has unpushed commits or uncommitted changes"
+        ui_info "$(ui_dim "Push or stash your work first, or re-run with --force to discard it.")"
+        ui_outro_cancel "Aborted"
+        return 1
+    fi
+
+    rm -rf "$ws_dir"
+
+    ui_step_done "Deleted:" ".revo/workspaces/$name"
+    ui_outro "Workspace removed"
+    return 0
+}
+
+# --- clean ---
+
+_workspace_clean() {
+    local ws_root="$REVO_WORKSPACE_ROOT/.revo/workspaces"
+
+    ui_intro "Revo - Clean Merged Workspaces"
+
+    if [[ ! -d "$ws_root" ]]; then
+        ui_info "No workspaces"
+        ui_outro "Nothing to clean"
+        return 0
+    fi
+
+    local default_branch
+    default_branch=$(config_default_branch)
+    [[ -z "$default_branch" ]] && default_branch="main"
+
+    local cleaned=0
+    local kept=0
+    local d
+    for d in "$ws_root"/*/; do
+        [[ -d "$d" ]] || continue
+        d="${d%/}"
+        local name
+        name=$(basename "$d")
+
+        if _workspace_all_merged "$d" "$default_branch"; then
+            rm -rf "$d"
+            ui_step_done "Removed (merged):" "$name"
+            cleaned=$((cleaned + 1))
+        else
+            ui_step_done "Kept:" "$name"
+            kept=$((kept + 1))
+        fi
+    done
+
+    ui_bar_line
+    ui_outro "Cleaned $cleaned, kept $kept"
+    return 0
+}
+
+# --- list (revo workspaces) ---
+
+cmd_workspaces() {
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                printf 'Usage: revo workspaces\n\n'
+                printf 'List all active workspaces with branch, age, and dirty state.\n'
+                return 0
+                ;;
+            *)
+                ui_step_error "Unknown option: $1"
+                return 1
+                ;;
+        esac
+    done
+
+    config_require_workspace || return 1
+
+    ui_intro "Revo - Workspaces"
+
+    local ws_root="$REVO_WORKSPACE_ROOT/.revo/workspaces"
+    if [[ ! -d "$ws_root" ]]; then
+        ui_info "No workspaces"
+        ui_bar_line
+        ui_info "$(ui_dim "Create one with: revo workspace <name>")"
+        ui_outro "Done"
+        return 0
+    fi
+
+    # Count first so we can short-circuit empty
+    local total=0
+    local d
+    for d in "$ws_root"/*/; do
+        [[ -d "$d" ]] || continue
+        total=$((total + 1))
+    done
+
+    if [[ $total -eq 0 ]]; then
+        ui_info "No workspaces"
+        ui_bar_line
+        ui_info "$(ui_dim "Create one with: revo workspace <name>")"
+        ui_outro "Done"
+        return 0
+    fi
+
+    ui_table_widths 24 24 8 7 12
+    ui_table_header "Workspace" "Branch" "Age" "Repos" "Dirty"
+
+    local now
+    now=$(date +%s)
+
+    for d in "$ws_root"/*/; do
+        [[ -d "$d" ]] || continue
+        d="${d%/}"
+        local name
+        name=$(basename "$d")
+
+        local mtime
+        mtime=$(_workspace_mtime "$d")
+        local age_secs=$((now - mtime))
+        local age
+        age=$(_workspace_format_age "$age_secs")
+
+        local repos_in_ws=0
+        local dirty_count=0
+        local branch=""
+        local repo
+        while IFS= read -r repo; do
+            [[ -z "$repo" ]] && continue
+            repos_in_ws=$((repos_in_ws + 1))
+            if [[ -z "$branch" ]]; then
+                branch=$(git -C "$repo" rev-parse --abbrev-ref HEAD 2>/dev/null || printf '?')
+            fi
+            if [[ -n "$(git -C "$repo" status --porcelain 2>/dev/null)" ]]; then
+                dirty_count=$((dirty_count + 1))
+            fi
+        done <<< "$(_workspace_repo_dirs "$d")"
+
+        [[ -z "$branch" ]] && branch="$(ui_dim "-")"
+
+        local dirty_text
+        if [[ $dirty_count -gt 0 ]]; then
+            dirty_text="$(ui_yellow "$dirty_count dirty")"
+        else
+            dirty_text="$(ui_green "clean")"
+        fi
+
+        ui_table_row "$name" "$branch" "$age" "$repos_in_ws" "$dirty_text"
+    done
+
+    ui_bar_line
+    ui_outro "$total workspace(s)"
+    return 0
+}
+
+# --- entry point: revo workspace ---
+
+cmd_workspace() {
+    local name=""
+    local tag=""
+    local action="create"
+    local force=0
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --tag)
+                tag="$2"
+                shift 2
+                ;;
+            --delete)
+                action="delete"
+                shift
+                ;;
+            --clean)
+                action="clean"
+                shift
+                ;;
+            --force|-f)
+                force=1
+                shift
+                ;;
+            --help|-h)
+                cat << 'EOF'
+Usage:
+  revo workspace <name> [--tag TAG]   Create a workspace (full copy of repos)
+  revo workspace <name> --delete [--force]
+                                       Delete a workspace
+  revo workspace --clean              Remove workspaces whose branches are merged
+  revo workspaces                     List active workspaces
+
+Workspaces are full copies of all repos (or a tagged subset) under
+.revo/workspaces/<name>/. Each workspace gets its own feature/<name>
+branch. Hardlinks are used where possible so the cost is near-zero.
+
+Run revo from inside .revo/workspaces/<name>/ and it automatically
+operates on the workspace's repos rather than the source tree.
+
+EOF
+                return 0
+                ;;
+            -*)
+                ui_step_error "Unknown option: $1"
+                return 1
+                ;;
+            *)
+                if [[ -z "$name" ]]; then
+                    name="$1"
+                else
+                    ui_step_error "Unexpected argument: $1"
+                    return 1
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    config_require_workspace || return 1
+
+    case "$action" in
+        clean)
+            _workspace_clean
+            ;;
+        delete)
+            if [[ -z "$name" ]]; then
+                ui_step_error "Usage: revo workspace <name> --delete [--force]"
+                return 1
+            fi
+            _workspace_delete "$name" "$force"
+            ;;
+        create)
+            if [[ -z "$name" ]]; then
+                ui_step_error "Usage: revo workspace <name> [--tag TAG]"
+                return 1
+            fi
+            _workspace_create "$name" "$tag" "$force"
+            ;;
+    esac
+}
+
 # === Main ===
 # --- Help ---
 show_help() {
@@ -4122,6 +4944,10 @@ Claude-first commands:
   pr TITLE [--tag TAG]        Create coordinated PRs via gh CLI
   issue list [options]        List issues across workspace repos
   issue create [options] TITLE Create issue(s) in workspace repos
+  workspace NAME [--tag TAG]  Create a full-copy workspace under .revo/workspaces/
+  workspace NAME --delete     Delete a workspace (use --force to discard work)
+  workspace --clean           Remove workspaces whose branches are merged
+  workspaces                  List active workspaces
 
 Options:
   --tag TAG       Filter repositories by tag
@@ -4147,6 +4973,10 @@ Examples:
   revo issue list --tag backend --json               # JSON for Claude/jq
   revo issue create --repo backend "Add stats endpoint"
   revo issue create --tag mobile --feature stats "Add statistics screen"
+  revo workspace clock-student                    # full copy of all repos
+  revo workspace clock-student --tag backend      # only backend repos
+  revo workspaces                                 # list active workspaces
+  revo workspace clock-student --delete           # remove when done
 
 Documentation: https://github.com/jippylong12/revo
 EOF
@@ -4218,6 +5048,12 @@ main() {
         issue|issues)
             cmd_issue "$@"
             ;;
+        workspace)
+            cmd_workspace "$@"
+            ;;
+        workspaces)
+            cmd_workspaces "$@"
+            ;;
         --help|-h|help)
             show_help
             ;;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revotools/cli",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Claude-first multi-repo workspace manager (fork of Mars)",
   "bin": {
     "revo": "./dist/revo"