revamp for a better mega merge flow (#1)

Author: Coobaha

.claude/parallel-agents-starter.md

@@ -49,3 +49,4 @@ bin/jjtask-go
 claude-plugin/bin/jjtask-go
 /jjtask
 tmp
+.dev-backup

.gitignore

@@ -8,9 +8,9 @@ description = "Build the jjtask binary"
 run = "go build -o bin/jjtask-go ./cmd/jjtask"
 
 [tasks.test]
-description = "Run integration tests"
+description = "Run Go integration tests"
 depends = ["build"]
-run = "./test.sh"
+run = "go test ./cmd/jjtask/cmd/..."
 
 [tasks.lint]
 description = "Run golangci-lint"

.mise.toml

@@ -12,10 +12,9 @@ jjtask is a portable Claude Code plugin for structured task management using JJ
 jjtask/
 ├── cmd/jjtask/             # Go CLI source
 │   ├── main.go             # Entry point
-│   └── cmd/                # Cobra commands (find, create, flag, next, etc.)
+│   └── cmd/                # Cobra commands (wip, done, drop, squash, find, create, etc.)
 ├── internal/               # Go internal packages
 │   ├── jj/                 # JJ interaction layer
-│   ├── parallel/           # Parallel agent session management
 │   └── workspace/          # Multi-workspace support
 ├── bin/
 │   ├── jjtask              # Dispatcher (downloads/runs jjtask-go)
@@ -31,25 +30,23 @@ jjtask/
 ├── shell/fish/
 │   ├── completions/        # Generated fish completions
 │   └── functions/          # jjtask-env.fish shell setup
-├── test/                   # Integration tests and snapshots
+├── test/                   # Test snapshots (test/snapshots_go/)
 ├── .github/workflows/      # CI and release automation
 ├── install.sh              # Installer (builds Go, symlinks, completions)
-├── test.sh                 # Integration test runner
 └── .mise.toml              # Toolchain and tasks (Go 1.25, golangci-lint)
 ```
 
 ## Multi-Workspace Support
 
-For projects with multiple jj repos, create `.jj-workspaces.yaml` in project root:
+For projects with multiple jj repos, create `.jjtask.toml` in project root:
 
-```yaml
-repos:
-  - path: frontend
-    name: frontend
-  - path: backend
-    name: backend
-  - path: .
-    name: root
+```toml
+[workspaces]
+repos = [
+  { path = "frontend", name = "frontend" },
+  { path = "backend", name = "backend" },
+  { path = ".", name = "root" },
+]
 ```
 
 Scripts auto-detect this config and operate across all repos:
@@ -81,10 +78,11 @@ mise run dev       # Dev setup: symlinks + completions
 
 Manual workflow:
 ```bash
-go build -o bin/jjtask-go ./cmd/jjtask   # Build
-./test.sh                                 # Test
-./install.sh                              # Install to ~/.local/bin
-./install.sh --uninstall                  # Remove
+go build -o bin/jjtask-go ./cmd/jjtask            # Build
+go test ./cmd/jjtask/cmd/...                      # Test all
+go test ./cmd/jjtask/cmd/... -v -run TestCreate   # Filter tests
+./install.sh                                      # Install to ~/.local/bin
+./install.sh --uninstall                          # Remove
 ```
 
 ## Releasing
@@ -105,8 +103,8 @@ This will:
 - Go code in `cmd/jjtask/cmd/` for commands, `internal/` for shared packages
 - Use Cobra for CLI structure with persistent flags for JJ globals (-R, --quiet)
 - Prefer `change_id.shortest()` over `change_id.short()` in templates
-- Integration tests use snapshot comparison (test/snapshots/)
-- Update snapshots with `SNAPSHOT_UPDATE=1 ./test.sh`
+- Integration tests use snapshot comparison (test/snapshots_go/)
+- Update snapshots with `SNAPSHOT_UPDATE=1 go test ./cmd/jjtask/cmd/...`
 
 ## Creating Skills/Commands
 

CLAUDE.md

@@ -24,18 +24,18 @@ claude plugin install jjtask@jjtask-marketplace
 
 ## Workflow
 
-jjtask enables a two-role workflow: Planners create task specifications, Workers implement them.
+jjtask uses a "mega-merge" model: @ is always a merge of all active work.
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │                     PLANNING PHASE                          │
 ├─────────────────────────────────────────────────────────────┤
 │  1. Create task DAG with specifications                     │
-│     jj task create @ "Add user auth" "## Requirements..."   │
-│     jj task parallel @ "Frontend" "Backend" "Tests"         │
+│     jjtask create "Add user auth" "## Requirements..."      │
+│     jjtask parallel "Frontend" "Backend" "Tests"            │
 │                                                             │
 │  2. Review structure                                        │
-│     jj task find                                            │
+│     jjtask find                                             │
 │                                                             │
 │  Result: Empty revisions with [task:todo] flags             │
 └─────────────────────────────────────────────────────────────┘
@@ -44,27 +44,26 @@ jjtask enables a two-role workflow: Planners create task specifications, Workers
 ┌─────────────────────────────────────────────────────────────┐
 │                     WORKING PHASE                           │
 ├─────────────────────────────────────────────────────────────┤
-│  3. Pick a task and start working                           │
-│     jj edit <task-id>                                       │
-│     jj task flag @ wip                                      │
+│  3. Start working on a task (@ becomes merge of active)     │
+│     jjtask wip <task-id>                                    │
 │                                                             │
-│  4. Implement according to specs in description             │
+│  4. Work directly in @ - changes go to merged tasks         │
 │     # write code, make changes                              │
 │                                                             │
-│  5. Review specs, check acceptance criteria                 │
-│     jj task next                    # shows current specs   │
+│  5. Complete task when ALL criteria met                     │
+│     jjtask done                                             │
 │                                                             │
-│  6. Transition when ALL criteria met                        │
-│     jj task next --mark-as done <next-task>                 │
+│  6. Ready to push? Flatten the merge                        │
+│     jjtask squash                                           │
 └─────────────────────────────────────────────────────────────┘
 ```
 
 ### Workflow Rules
 
 - Never mark `done` unless ALL acceptance criteria pass
-- Use `blocked`, `review`, or `untested` if criteria aren't fully met
+- Use `jjtask flag blocked/review/untested` if criteria aren't fully met
 - Task descriptions are specifications - follow them exactly
-- `jj task next` shows specs and available transitions
+- @ is always a merge of all WIP + done-with-content tasks
 
 ## Task Flags
 
@@ -116,24 +115,24 @@ The `label("task " ++ task_flag, ...)` applies colors defined in jjtask's `[colo
 
 ## Commands
 
-All commands work as `jj task <cmd>` (requires alias in config) or `jjtask <cmd>` directly:
-
 | Command | Action |
 | --- | --- |
-| `jj task find [flag]` | List tasks by status |
-| `jj task create [parent] <title> [desc]` | Create task revision |
-| `jj task flag <rev> <flag>` | Update task status |
-| `jj task next [--mark-as flag] [rev]` | Review current task, transition to next |
-| `jj task finalize [rev]` | Strip [task:*] for final commit |
-| `jj task parallel <parent> <t1> <t2>...` | Create sibling tasks |
-| `jj task hoist` | Rebase pending tasks to @- |
-| `jj task show-desc [rev]` | Print revision description |
-| `jj task checkpoint [name]` | Create named checkpoint |
+| `jjtask create <title> [desc]` | Create task revision |
+| `jjtask wip [task]` | Mark WIP, rebuild @ as merge |
+| `jjtask done [task]` | Mark done (stays in @ if content) |
+| `jjtask drop <task>` | Remove from @ (mark standby) |
+| `jjtask squash` | Flatten @ merge for push |
+| `jjtask find [-s status]` | List tasks by status |
+| `jjtask flag <status> [-r rev]` | Update task status |
+| `jjtask parallel <t1> <t2>...` | Create sibling tasks |
+| `jjtask show-desc [-r rev]` | Print revision description |
+| `jjtask checkpoint [name]` | Create named checkpoint |
 
 Multi-repo support (requires `.jj-workspaces.yaml`):
+
 | Command | Action |
 | --- | --- |
-| `jj task all <cmd> [args]` | Run jj command across repos |
+| `jjtask all <cmd> [args]` | Run jj command across repos |
 
 ## Installation
 
@@ -182,7 +181,7 @@ repos:
     name: backend
 ```
 
-Then `jj task find` and `jj task all` operate across all repos.
+Then `jjtask find` and `jjtask all` operate across all repos.
 
 ## Writing Good Task Descriptions
 

README.md

@@ -115,10 +115,10 @@ case "$1" in
         fi
         ;;
     rebase)
-        show_hint rebase "AGENT HINT: For hoisting pending tasks to @: jjtask hoist"
+        show_hint rebase "AGENT HINT: Use 'jjtask wip TASK' to start working (rebuilds @ as merge)"
         ;;
     edit)
-        show_hint edit "AGENT HINT: For task transitions: jjtask next --mark-as STATUS REV"
+        show_hint edit "AGENT HINT: Use 'jjtask wip TASK' to start, 'jjtask done TASK' to complete"
         ;;
 esac