Migrate

Skill mattjaikaran/torque/skills/migrate

Skill for routes between GSD project management and Superpowers engineering discipline

Install

npx -y skills add mattjaikaran/torque --skill migrate

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

6 stars6 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Evaluate whether to upgrade from Torque (GSD + Superpowers) to Meridian, and guide the migration if ready. Use when projects outgrow the routing model.

SKILL.md

5.0 KB, as published. Nobody here has run it

Migrate to Meridian

Evaluate whether the current project would benefit from upgrading to Meridian and provide a migration path.

What is Meridian?

Meridian is the standalone successor to Torque. Instead of routing between GSD and Superpowers, Meridian IS the system — a SQLite-backed state machine with 39 commands, deterministic resume, quality gates, and remote agent dispatch.

When to Migrate

Signals you've outgrown Torque

Run through this checklist. If 3+ are true, Meridian is the right move.

Session continuity is painful — you lose context between sessions and /gsd:resume-work isn't enough
Multi-milestone project — you've completed 1+ milestones and are starting another
Team coordination — multiple people or AI agents need to work on the project
You want deterministic resume — same state should produce the exact same prompt every time
You need board sync — Linear, Jira, or similar needs to stay in sync with phases
Remote execution — you want to dispatch plans to other machines or agents
Execution learnings — you want the system to learn from failures and improve over time
You're fighting the routing — GSD and SP conflict resolution is becoming overhead

Stay with Torque if

Project is simple (< 3 milestones expected)
You like GSD and Superpowers separately and just need them coordinated
You don't need persistent state beyond .planning/ files
Lightweight is a feature, not a limitation

Migration Path

Step 1: Install Meridian

git clone https://github.com/mattjaikaran/meridian.git ~/.claude/skills/meridian

Step 2: Initialize in your project

# In your project directory
# Meridian will detect existing .planning/ and offer to import

Then run /meridian:init — it creates .meridian/state.db and imports existing state.

Step 3: Map your workflow

Torque (GSD + SP)	Meridian equivalent
`/gsd:new-project`	`/meridian:init`
`/gsd:discuss-phase`	`/meridian:discuss`
`/gsd:spec-phase`	`/meridian:discuss` (spec built-in)
`/gsd:plan-phase`	`/meridian:plan`
`/gsd:execute-phase`	`/meridian:execute`
`/gsd:verify-work`	`/meridian:verify-phase`
`/gsd:validate-phase`	`/meridian:verify-phase` (Nyquist built-in)
`/gsd:resume-work`	`/meridian:resume` (deterministic)
`/gsd:quick`	`/meridian:quick`
`/gsd:fast`	`/meridian:fast`
`/gsd:ship`	`/meridian:ship`
`/gsd:pr-branch`	`/meridian:pr-branch`
`/gsd:autonomous`	`/meridian:autonomous`
`/gsd:insert-phase`	`/meridian:insert-phase`
`/gsd:remove-phase`	`/meridian:remove-phase`
`/gsd:undo`	`/meridian:revert`
`requesting-code-review`	`/meridian:review` (two-stage)
`receiving-code-review`	`/meridian:review` (handles both sides)
`systematic-debugging`	`/meridian:debug` (with KB)
`/gsd:note`	`/meridian:note`
`/gsd:plant-seed`	`/meridian:seed`
`/gsd:session-report`	`/meridian:report`
`/torque:status`	`/meridian:status` or `/meridian:dashboard`
`/torque:next`	`/meridian:next`

Step 4: What you gain

Deterministic resume: SQLite-backed, not file-based. Same state = same prompt.
Quality gates: Regression gate, stub detection, coverage tracking — enforced, not suggested.
Two-stage review: Spec compliance first, then code quality. Built-in, not bolted on.
Execution learnings: System learns from failures and injects rules into future plans.
Debug knowledge base: Resolved bugs persist and inform future debugging.
Board sync: Connect Linear/Jira with a pluggable provider.
Remote dispatch: Send plans to other agents for autonomous execution.
39 commands: Everything Torque routes to, Meridian provides natively.

Step 5: Clean up

After migrating, you can optionally remove Torque:

rm -rf ~/.claude/skills/torque

The .planning/ directory is still valid — Meridian uses .meridian/ alongside it.

Output format

After evaluating the checklist:

## Migration Assessment

**Score**: 5/8 signals detected — Meridian recommended

### Signals detected
✓ Multi-milestone project (2 milestones completed)
✓ Session continuity issues (3 HANDOFF.md files found)
✓ Complex routing (both .planning/ and docs/plans/ present)
✗ No board sync needed
✗ No remote execution needed

### Recommendation
→ Install Meridian and run `/meridian:init` in this project.
   Your existing .planning/ state will be imported automatically.

Rules

Never modify any files. This is assessment-only unless the user explicitly asks to migrate.
Be honest — if Torque is sufficient, say so.
Always show the command mapping table so the user knows what changes.