diff --git a/CLAUDE.md b/CLAUDE.md
index 64efdb85..c2025999 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -100,7 +100,7 @@ cmd/             - CLI commands (cobra)
   ├── worker.go  - ttal worker close/list
   ├── today.go   - ttal today list/completed/add/remove (daily focus)
   ├── task.go    - ttal task get/find (taskwarrior queries)
-  └── advance.go - ttal task advance (pipeline stage engine)
+  └── go.go      - ttal task go (pipeline stage engine)
 
 internal/
   ├── agentfs/   - Filesystem-based agent discovery (CLAUDE.md frontmatter)
@@ -127,7 +127,7 @@ inter-agent and human-agent messaging. **Do not add fallback logic** — each pa
 | `ttal send --to kestrel` | tmux send-keys | `handleTo` |
 | `ttal send --to kestrel` (with TTAL_AGENT_NAME) | tmux send-keys + attribution | `handleAgentToAgent` |
 | on-add hook (task created) | Inline enrichment (project_path, branch) | `HookOnAdd` → `enrichInline` |
-| `ttal task advance <uuid>` | Pipeline advance via CLI | `handlePipelineAdvance` → `advanceToStage` |
+| `ttal task go <uuid>` | Pipeline advance via CLI | `handlePipelineAdvance` → `advanceToStage` |
 | Cleanup watcher (fsnotify) | Close worker + mark done | `startCleanupWatcher` → `worker.Close` → `MarkDone` |
 
 Socket protocol uses `SendRequest{From, To, Message}` — direction is inferred from which fields
diff --git a/CLAUDE.user.md b/CLAUDE.user.md
index f5fda986..87f44b5c 100644
--- a/CLAUDE.user.md
+++ b/CLAUDE.user.md
@@ -43,7 +43,7 @@ Workers automatically look for flicknote notes in projects named `*plan*` or `*f
 
 ### Step 3: Execute
 ```bash
-ttal task execute <uuid>    # spawns a worker in isolated worktree
+ttal task go <uuid>    # spawns a worker in isolated worktree
 ```
 
 ## GitHub & Forgejo
@@ -126,13 +126,11 @@ ttal task get <uuid>         # get formatted task prompt
 Route tasks to the right agent instead of doing everything yourself.
 
 ```bash
-ttal task route <uuid> --to <agent>    # route to agent for design/research/brainstorm
-ttal task execute <uuid>               # spawn a worker to implement the task
+ttal task go <uuid>    # advance task through pipeline stage (route to agent or spawn worker)
 ```
 
 **When to use:**
-- `ttal task route` — task needs design, research, or brainstorming. Use `/task-route` command to classify readiness and pick the right agent.
-- `ttal task execute` — task has a plan/design doc annotated and is ready to implement. Spawns a Claude Code worker in its own tmux session + git worktree.
+- `ttal task go` — advances the task to the next pipeline stage. Routes to the right agent (design/research) or spawns a worker, based on `pipelines.toml`.
 
 ### Ask
 
@@ -210,8 +208,7 @@ ttal task add --project <alias> "description" --tag <tag> --priority M --annotat
 ttal task get <uuid>                    # rich prompt with inlined docs
 ttal task find <keyword>                # search pending tasks
 ttal task find <keyword> --completed    # search completed tasks
-ttal task route <uuid> --to <agent>    # route to a specific agent
-ttal task execute <uuid>               # spawn worker
+ttal task go <uuid>                    # advance task through pipeline stage
 ```
 
 ## PRs
diff --git a/README.md b/README.md
index 32845666..59906d7a 100644
--- a/README.md
+++ b/README.md
@@ -30,14 +30,8 @@ All automatic. All in your terminal.
 # Create a task
 ttal task add --project myapp "Add JWT authentication to the API"
 
-# Route to researcher — she investigates options, writes findings
-ttal task route abc12345 --to athena
-
-# Route to designer — he reads research, writes the implementation plan
-ttal task route abc12345 --to inke
-
-# Execute — worker spawns in its own worktree, follows the plan, opens a PR
-ttal task advance abc12345
+# Advance — routes to researcher, designer, or spawns worker based on pipeline stage
+ttal task go abc12345
 
 # Meanwhile, you're on your phone
 # Review agents post verdicts, worker triages feedback, you merge from Telegram
diff --git a/RULE.md b/RULE.md
index dfc95f73..5bfae93c 100644
--- a/RULE.md
+++ b/RULE.md
@@ -14,8 +14,7 @@ ttal task add --project <alias> "description" --tag <tag> --priority M --annotat
 ttal task get <uuid>                    # rich prompt with inlined docs
 ttal task find <keyword>                # search pending tasks
 ttal task find <keyword> --completed    # search completed tasks
-ttal task route <uuid> --to <agent>    # route to a specific agent (legacy — prefer advance)
-ttal task advance <uuid>               # advance task through pipeline stage
+ttal task go <uuid>                    # advance task through pipeline stage
 ```
 
 ## PRs
diff --git a/cmd/advance_test.go b/cmd/advance_test.go
deleted file mode 100644
index 08f6e180..00000000
--- a/cmd/advance_test.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package cmd
-
-import (
-	"testing"
-)
-
-func TestAdvanceCmdExists(t *testing.T) {
-	// Verify advance subcommand is registered on the task command.
-	var found bool
-	for _, sub := range taskCmd.Commands() {
-		if sub.Name() == "advance" {
-			found = true
-			break
-		}
-	}
-	if !found {
-		t.Error("ttal task advance command not found")
-	}
-}
-
-func TestAdvanceCmd_RequiresUUID(t *testing.T) {
-	// Advance requires exactly one UUID argument.
-	if taskAdvanceCmd.Args == nil {
-		t.Error("expected Args validator on advance command")
-	}
-}
diff --git a/cmd/advance.go b/cmd/go.go
similarity index 91%
rename from cmd/advance.go
rename to cmd/go.go
index b833c6da..45cdae86 100644
--- a/cmd/advance.go
+++ b/cmd/go.go
@@ -9,8 +9,8 @@ import (
 	"github.com/tta-lab/ttal-cli/internal/taskwarrior"
 )
 
-var taskAdvanceCmd = &cobra.Command{
-	Use:   "advance <uuid>",
+var taskGoCmd = &cobra.Command{
+	Use:   "go <uuid>",
 	Short: "Advance a task to the next pipeline stage",
 	Long: `Advance a task through its pipeline stages based on pipelines.toml configuration.
 
@@ -21,8 +21,8 @@ is determined by the task's pipeline stage definition.
 Human gate stages block until Telegram approval is received.
 
 Examples:
-  ttal task advance abc12345
-  ttal task advance abc12345-1234-1234-1234-123456789abc`,
+  ttal task go abc12345
+  ttal task go abc12345-1234-1234-1234-123456789abc`,
 	Args: cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		uuid := args[0]
diff --git a/cmd/go_test.go b/cmd/go_test.go
new file mode 100644
index 00000000..4ad6e6b2
--- /dev/null
+++ b/cmd/go_test.go
@@ -0,0 +1,26 @@
+package cmd
+
+import (
+	"testing"
+)
+
+func TestGoCmdExists(t *testing.T) {
+	// Verify go subcommand is registered on the task command.
+	var found bool
+	for _, sub := range taskCmd.Commands() {
+		if sub.Name() == "go" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Error("ttal task go command not found")
+	}
+}
+
+func TestGoCmd_RequiresUUID(t *testing.T) {
+	// Go requires exactly one UUID argument.
+	if taskGoCmd.Args == nil {
+		t.Error("expected Args validator on go command")
+	}
+}
diff --git a/cmd/task.go b/cmd/task.go
index 8373d1d4..7717f6d3 100644
--- a/cmd/task.go
+++ b/cmd/task.go
@@ -237,7 +237,7 @@ func init() {
 	taskCmd.AddCommand(taskGetCmd)
 	taskCmd.AddCommand(taskFindCmd)
 	taskCmd.AddCommand(taskAddCmd)
-	taskCmd.AddCommand(taskAdvanceCmd)
+	taskCmd.AddCommand(taskGoCmd)
 	taskCmd.AddCommand(taskCommentCmd)
 	taskCmd.AddCommand(taskHeatmapCmd)
 
diff --git a/docs/blog/philosophy.md b/docs/blog/philosophy.md
index 0b85c9ab..754287d5 100644
--- a/docs/blog/philosophy.md
+++ b/docs/blog/philosophy.md
@@ -51,7 +51,7 @@ This creates a concrete constraint on design: ttal must be ergonomic for both hu
 
 ```bash
 # An agent running ttal to spawn another agent's work
-ttal task advance a1b2c3d4
+ttal task go a1b2c3d4
 
 # An agent querying its own task queue
 ttal task find refactor --completed
diff --git a/docs/blog/the-glue-layer.md b/docs/blog/the-glue-layer.md
index 327eabbe..e891f225 100644
--- a/docs/blog/the-glue-layer.md
+++ b/docs/blog/the-glue-layer.md
@@ -66,7 +66,7 @@ The key components:
 |-----------|--------------|
 | **Daemon** | Long-running process; handles socket connections, Telegram, fsnotify watchers |
 | **on-add-ttal hook** | Fires when a task is created; enriches with project path and branch |
-| **Worker spawn** | `ttal task advance <uuid>` → tmux session + git worktree + coding agent |
+| **Worker spawn** | `ttal task go <uuid>` → tmux session + git worktree + coding agent |
 | **Cleanup watcher** | Watches for worker completion; closes session, removes worktree, marks task done |
 | **ttal send** | Agent-to-agent messaging via daemon socket |
 
@@ -88,7 +88,7 @@ The manager/worker distinction survived the migration. It's too useful to abando
 │  └─────────────┘  └─────────────┘  └────────┬────────┘  │
 │                                             │           │
 └─────────────────────────────────────────────┼───────────┘
-                                              │ ttal task execute
+                                              │ ttal task go
                                               ▼
 ┌─────────────────────────────────────────────────────────┐
 │              Worker Plane (tmux + worktree)              │
@@ -128,7 +128,7 @@ This means the stack doesn't break when a new coding agent appears. Swap the run
 ## The Full Loop
 
 ```
-You: ttal task advance a1b2c3d4
+You: ttal task go a1b2c3d4
   ↓
 ttal daemon: reads task, resolves project path
   ↓
diff --git a/docs/docs/configuration.md b/docs/docs/configuration.md
index 79788b2d..46feadf1 100644
--- a/docs/docs/configuration.md
+++ b/docs/docs/configuration.md
@@ -135,7 +135,7 @@ re_review = "{{skill:pr-review}}\nRe-review the fixes: {{review-scope}}"
 
 | Key | Used by | Template variables |
 |-----|---------|-------------------|
-| `execute` | `ttal task execute` | `{{task-id}}`, `{{skill:name}}` |
+| `execute` | `ttal task go` | `{{task-id}}`, `{{skill:name}}` |
 | `triage` | PR review → coder | `{{review-file}}`, `{{skill:name}}` |
 | `review` | Reviewer initial prompt | `{{pr-number}}`, `{{pr-title}}`, `{{owner}}`, `{{repo}}`, `{{branch}}`, `{{skill:name}}` |
 | `re_review` | Re-review after fixes | `{{review-scope}}`, `{{coder-comment}}`, `{{skill:name}}` |
diff --git a/docs/docs/daemon.md b/docs/docs/daemon.md
index ff85ad29..f77fcb88 100644
--- a/docs/docs/daemon.md
+++ b/docs/docs/daemon.md
@@ -11,7 +11,7 @@ The daemon is a long-running process that acts as the communication hub for your
 - **Message delivery** — delivers messages to agent tmux sessions via `send-keys`
 - **JSONL bridge** — tails active Claude Code session files and sends assistant output to Telegram
 - **Cleanup watcher** — processes post-merge cleanup requests (close session, remove worktree, mark task done)
-- **Task routing** — handles `ttal task route --to <agent>` by delivering prompts to agent sessions
+- **Task routing** — handles `ttal task go <uuid>` by advancing tasks through pipeline stages
 
 ## Installation
 
diff --git a/docs/docs/prompts.md b/docs/docs/prompts.md
index 5ec5da61..e9b2bed0 100644
--- a/docs/docs/prompts.md
+++ b/docs/docs/prompts.md
@@ -42,9 +42,9 @@ as all runtimes require skill invocations at the start of the message.
 
 | Key | Used by | Template variables |
 |-----|---------|-------------------|
-| `designer` | `ttal task route --to <agent>` (agent with `role: designer`) | `{{task-id}}`, `{{skill:name}}` |
-| `researcher` | `ttal task route --to <agent>` (agent with `role: researcher`) | `{{task-id}}`, `{{skill:name}}` |
-| `execute` | `ttal task execute` | `{{task-id}}`, `{{skill:name}}` |
+| `designer` | `ttal task go <uuid>` (agent with `role: designer`) | `{{task-id}}`, `{{skill:name}}` |
+| `researcher` | `ttal task go <uuid>` (agent with `role: researcher`) | `{{task-id}}`, `{{skill:name}}` |
+| `execute` | `ttal task go` | `{{task-id}}`, `{{skill:name}}` |
 | `triage` | PR review → coder | `{{review-file}}`, `{{skill:name}}` |
 | `review` | Reviewer initial prompt | `{{pr-number}}`, `{{pr-title}}`, `{{owner}}`, `{{repo}}`, `{{branch}}`, `{{skill:name}}` |
 | `re_review` | Re-review after fixes | `{{review-scope}}`, `{{coder-comment}}`, `{{skill:name}}` |
@@ -53,19 +53,19 @@ as all runtimes require skill invocations at the start of the message.
 
 ### `execute`
 
-The execute prompt is prepended to the worker's spawn prompt. When you run `ttal task advance <uuid>`, the worker receives this prompt followed by the task context (description, annotations, inlined docs).
+The execute prompt is prepended to the worker's spawn prompt. When you run `ttal task go <uuid>`, the worker receives this prompt followed by the task context (description, annotations, inlined docs).
 
 Default: invokes the executing-plans skill to implement the task step by step.
 
 ### `designer`
 
-Controls what gets sent when you run `ttal task advance <uuid>` where the agent has `role: designer`. The agent receives this prompt with the task UUID, reads the task details, and writes an implementation plan.
+Controls what gets sent when you run `ttal task go <uuid>` where the agent has `role: designer`. The agent receives this prompt with the task UUID, reads the task details, and writes an implementation plan.
 
 Default: asks the agent to write a plan document and annotate the task with its path.
 
 ### `researcher`
 
-Controls what gets sent when you run `ttal task advance <uuid>` where the agent has `role: researcher`. The agent receives this prompt, investigates the topic, and writes findings.
+Controls what gets sent when you run `ttal task go <uuid>` where the agent has `role: researcher`. The agent receives this prompt, investigates the topic, and writes findings.
 
 Default: asks the agent to research the topic and annotate the task with the findings path.
 
diff --git a/docs/docs/tasks.md b/docs/docs/tasks.md
index 3e71baef..0da1a33b 100644
--- a/docs/docs/tasks.md
+++ b/docs/docs/tasks.md
@@ -32,11 +32,8 @@ Accepts 8-character UUID prefixes or full UUIDs.
 Route tasks to specialized agents based on what needs to happen:
 
 ```bash
-# Route to a specific agent by name
-ttal task route <uuid> --to <agent-name>
-
-# Spawn a worker to implement
-ttal task advance <uuid>
+# Advance to next pipeline stage (routes to agent or spawns worker)
+ttal task go <uuid>
 ```
 
 ### Configuring route targets
@@ -56,7 +53,7 @@ role: researcher
 ---
 ```
 
-Use `ttal task advance <uuid>` to route to any agent by name (role determines which prompt is used).
+Use `ttal task go <uuid>` to route to any agent by name (role determines which prompt is used).
 
 ## Today's focus
 
diff --git a/docs/docs/workers.md b/docs/docs/workers.md
index 21d02f99..3bd362af 100644
--- a/docs/docs/workers.md
+++ b/docs/docs/workers.md
@@ -10,7 +10,7 @@ Workers are isolated coding sessions. Each worker runs in its own tmux session w
 The primary way to spawn a worker is through task execution:
 
 ```bash
-ttal task advance <uuid>
+ttal task go <uuid>
 ```
 
 This reads the task's metadata (project path, branch name) and spawns a worker with the right context.
@@ -100,7 +100,7 @@ This processes any pending cleanup request files that the daemon hasn't handled
 Spawn a worker to implement a task:
 
 ```bash
-ttal task advance <uuid>
+ttal task go <uuid>
 ```
 
 Without `--yes`, shows the project path and prompts for confirmation.
diff --git a/docs/guides/building-your-team.md b/docs/guides/building-your-team.md
index 90cc6467..cf602faf 100644
--- a/docs/guides/building-your-team.md
+++ b/docs/guides/building-your-team.md
@@ -15,7 +15,7 @@ The simplest setup. One persistent agent handles orchestration, and workers are
 ttal agent add kestrel --role orchestrator
 ```
 
-Kestrel manages your tasks, responds to Telegram messages, and spawns workers when you run `ttal task execute`. Each worker is isolated in its own tmux session and git worktree.
+Kestrel manages your tasks, responds to Telegram messages, and spawns workers when you run `ttal task go`. Each worker is isolated in its own tmux session and git worktree.
 
 **Best for:** Individual developers who want mobile access and task-driven workflows.
 
@@ -36,7 +36,7 @@ ttal agent modify inke role:designer
 ttal agent modify athena role:researcher
 ```
 
-Now `ttal task route <uuid> --to inke` goes to Inke (role: designer), `ttal task route <uuid> --to athena` goes to Athena (role: researcher), and `ttal task advance <uuid>` spawns a worker.
+Now `ttal task go <uuid>` advances the task through pipeline stages: routes to Athena (researcher) or Inke (designer) for early stages, and spawns a worker for implementation.
 
 **Best for:** Complex projects where tasks benefit from investigation and planning before implementation.
 
diff --git a/docs/guides/research-design-execute.md b/docs/guides/research-design-execute.md
index 04e83382..8be7ee75 100644
--- a/docs/guides/research-design-execute.md
+++ b/docs/guides/research-design-execute.md
@@ -10,7 +10,7 @@ The typical ttal workflow follows three phases: research the problem, design the
 ### 1. Research
 
 ```bash
-ttal task route <uuid> --to <researcher-agent>
+ttal task go <uuid>
 ```
 
 The research agent investigates the problem, explores options, and writes a findings document. It then annotates the task:
@@ -22,7 +22,7 @@ Research: ~/clawd/docs/research/2026-03-01-auth-options.md
 ### 2. Design
 
 ```bash
-ttal task route <uuid> --to <designer-agent>
+ttal task go <uuid>
 ```
 
 The design agent reads the task (including the research findings via the annotation), writes an implementation plan, and annotates the task:
@@ -34,7 +34,7 @@ Plan: ~/clawd/docs/plans/2026-03-01-auth-implementation.md
 ### 3. Execute
 
 ```bash
-ttal task advance <uuid>
+ttal task go <uuid>
 ```
 
 This spawns a worker in a tmux session with a git worktree. The worker receives the full task context — including the research findings and implementation plan, automatically inlined from annotations.
@@ -62,7 +62,7 @@ ttal task add --project myapp "Add JWT authentication to the API"
 ### Step 2: Research
 
 ```bash
-ttal task route <uuid> --to athena
+ttal task go <uuid>
 ```
 
 Athena (the research agent) investigates JWT libraries, compares options, and writes findings.
@@ -70,7 +70,7 @@ Athena (the research agent) investigates JWT libraries, compares options, and wr
 ### Step 3: Design
 
 ```bash
-ttal task route <uuid> --to inke
+ttal task go <uuid>
 ```
 
 Inke (the design agent) reads Athena's research, writes an implementation plan with specific files to modify, and annotates the task.
@@ -78,7 +78,7 @@ Inke (the design agent) reads Athena's research, writes an implementation plan w
 ### Step 4: Execute
 
 ```bash
-ttal task advance <uuid>
+ttal task go <uuid>
 ```
 
 A worker spawns with full context: the task description, Athena's research, and Inke's plan — all inlined in the prompt. The worker follows the plan, implements the feature, creates a PR.
@@ -91,6 +91,6 @@ The PR goes through automated review (6 specialized review agents), the worker t
 
 Not every task needs all three phases:
 
-- **Simple bug fix** — skip research and design, go straight to `ttal task execute`
-- **Well-understood feature** — skip research, route to designer with `ttal task route --to <agent>`, then execute
+- **Simple bug fix** — skip research and design, go straight to `ttal task go`
+- **Well-understood feature** — skip research, go straight to design stage with `ttal task go <uuid>`, then execute
 - **Exploratory work** — research only, then decide next steps based on findings
diff --git a/internal/doctor/pipelines.go b/internal/doctor/pipelines.go
index 4bb7a4f9..22b8ba4d 100644
--- a/internal/doctor/pipelines.go
+++ b/internal/doctor/pipelines.go
@@ -2,7 +2,7 @@ package doctor
 
 // defaultPipelinesContent is the starter pipelines.toml written by ttal doctor --fix.
 // It defines standard/bugfix/hotfix pipelines for the common ttal workflow.
-const defaultPipelinesContent = `# Pipeline definitions for ttal task advance.
+const defaultPipelinesContent = `# Pipeline definitions for ttal task go.
 # Each pipeline defines a sequence of stages with role-based assignment and gates.
 # Tasks are matched to pipelines by their tags.
 
diff --git a/internal/open/session.go b/internal/open/session.go
index ed417f27..2dcceda8 100644
--- a/internal/open/session.go
+++ b/internal/open/session.go
@@ -24,7 +24,7 @@ func Session(uuid string) error {
 	if !tmux.SessionExists(sessionName) {
 		return fmt.Errorf("no worker session assigned to this task\n\n"+
 			"  To spawn a worker for this task:\n"+
-			"  ttal task advance %s", uuid)
+			"  ttal task go %s", uuid)
 	}
 
 	tmuxBin, err := lookPath("tmux")
diff --git a/internal/sync/settings.go b/internal/sync/settings.go
index 62099f9e..1c1eb938 100644
--- a/internal/sync/settings.go
+++ b/internal/sync/settings.go
@@ -10,7 +10,7 @@ import (
 // DenyPrimaryAgentsAsSubagents reads ~/.claude/settings.json and ensures
 // Agent(<name>) deny entries exist for all deployed agents, preventing CC
 // from spawning them directly as subagents. All agent routing must go
-// through ttal task advance.
+// through ttal task go.
 //
 // Additive only — appends new entries at the end of the deny list,
 // never removes or reorders existing entries. Returns list of newly added entry names.
diff --git a/internal/taskwarrior/taskwarrior.go b/internal/taskwarrior/taskwarrior.go
index 1c702b0b..33290f16 100644
--- a/internal/taskwarrior/taskwarrior.go
+++ b/internal/taskwarrior/taskwarrior.go
@@ -186,7 +186,7 @@ func ValidateUUID(s string) error {
 		return userError("# prefix format is no longer supported\n\n"+
 			"  You provided: %s\n\n"+
 			"  Remove the # prefix:\n"+
-			"  ttal task advance %s", s, remaining)
+			"  ttal task go %s", s, remaining)
 	}
 
 	// Reject short numeric IDs (taskwarrior task numbers like "42", "123")
@@ -199,7 +199,7 @@ func ValidateUUID(s string) error {
 			"  # Get UUID for task #%s:\n"+
 			"  task %s export | jq -r '.[0].uuid'\n\n"+
 			"  # Then use the UUID:\n"+
-			"  ttal task advance <uuid>", s, s, s)
+			"  ttal task go <uuid>", s, s, s)
 	}
 
 	if !uuidPattern.MatchString(s) && !uuidPrefixPattern.MatchString(s) {
diff --git a/internal/tui/actions.go b/internal/tui/actions.go
index 512708d0..f57fc997 100644
--- a/internal/tui/actions.go
+++ b/internal/tui/actions.go
@@ -20,31 +20,17 @@ func runTtalCommand(args ...string) ([]byte, error) {
 	return exec.Command("ttal", args...).CombinedOutput()
 }
 
-func executeTask(uuid string) tea.Cmd {
+func advanceTask(uuid string) tea.Cmd {
 	return func() tea.Msg {
-		out, err := runTtalCommand("task", "execute", uuid)
+		out, err := runTtalCommand("task", "go", uuid)
 		short := uuid
 		if len(short) > 8 {
 			short = short[:8]
 		}
 		if err != nil {
-			return actionResultMsg{err: fmt.Errorf("execute %s: %s", short, strings.TrimSpace(string(out)))}
+			return actionResultMsg{err: fmt.Errorf("advance %s: %s", short, strings.TrimSpace(string(out)))}
 		}
-		return actionResultMsg{message: fmt.Sprintf("Worker spawned for %s", short), refresh: true}
-	}
-}
-
-func routeTask(uuid, agentName string) tea.Cmd {
-	return func() tea.Msg {
-		out, err := runTtalCommand("task", "route", uuid, "--to", agentName)
-		short := uuid
-		if len(short) > 8 {
-			short = short[:8]
-		}
-		if err != nil {
-			return actionResultMsg{err: fmt.Errorf("route %s to %s: %s", short, agentName, strings.TrimSpace(string(out)))}
-		}
-		return actionResultMsg{message: fmt.Sprintf("Routed %s to %s", short, agentName)}
+		return actionResultMsg{message: fmt.Sprintf("Advanced %s", short), refresh: true}
 	}
 }
 
diff --git a/internal/tui/keymap.go b/internal/tui/keymap.go
index b1184e32..18e9c661 100644
--- a/internal/tui/keymap.go
+++ b/internal/tui/keymap.go
@@ -11,8 +11,7 @@ const (
 	keyDown
 	keyEnter
 	keyEsc
-	keyExecute
-	keyRoute
+	keyAdvance
 	keyOpenPR
 	keyOpenSession
 	keyOpenTerm
@@ -54,8 +53,7 @@ var keyMap = map[string]keyAction{
 	"down":   keyDown,
 	"enter":  keyEnter,
 	"esc":    keyEsc,
-	"x":      keyExecute,
-	"r":      keyRoute,
+	"g":      keyAdvance,
 	"p":      keyOpenPR,
 	"s":      keyOpenSession,
 	"o":      keyOpenTerm,
@@ -80,7 +78,7 @@ var keyMap = map[string]keyAction{
 	"pgup":   keyPageUp,
 	"ctrl+d": keyHalfPageDown,
 	"ctrl+u": keyHalfPageUp,
-	"g":      keyTop,
+	"home":   keyTop,
 	"G":      keyBottom,
 }
 
@@ -96,11 +94,11 @@ const helpText = `Key Bindings:
   j/k, Up/Down   Navigate tasks
   Enter           Task detail
   Esc             Back / close overlay
-  g/G             Top / bottom
+  Home            Top
+  G               Bottom
   Ctrl+D/U        Half page down/up
 
-  x               Execute (spawn worker)
-  r               Route to manager (or pick agent if no manager configured)
+  g               Advance task (go — pipeline stage)
   d               Mark task done
   m               Modify task
   A               Annotate task
diff --git a/internal/tui/model.go b/internal/tui/model.go
index 28ff9fe2..274984f0 100644
--- a/internal/tui/model.go
+++ b/internal/tui/model.go
@@ -10,7 +10,6 @@ import (
 	"charm.land/bubbles/v2/spinner"
 	"charm.land/bubbles/v2/textinput"
 	tea "charm.land/bubbletea/v2"
-	"github.com/tta-lab/ttal-cli/internal/agentfs"
 	"github.com/tta-lab/ttal-cli/internal/config"
 	"github.com/tta-lab/ttal-cli/internal/taskwarrior"
 )
@@ -38,7 +37,6 @@ type Model struct {
 	// Data
 	tasks    []Task
 	filtered []Task
-	agents   []agentfs.AgentInfo
 	cfg      *config.Config
 	projects []string
 	tags     []string
@@ -49,10 +47,6 @@ type Model struct {
 	offset       int
 	searchInput  textinput.Model
 
-	// Route input
-	routeInput   textinput.Model
-	routeMatches []agentfs.AgentInfo
-
 	// Text input for overlays
 	modifyInput   textinput.Model
 	annotateInput textinput.Model
@@ -90,7 +84,6 @@ func NewModel() Model {
 		loading:        true,
 		offset:         0,
 		searchInput:    newTextInput("project:x +tag priority:H"),
-		routeInput:     newTextInput("agent name..."),
 		modifyInput:    newTextInput("+tag project:x priority:H"),
 		annotateInput:  newTextInput("annotation text"),
 		loadingSpinner: spinner.New(spinner.WithSpinner(spinner.MiniDot)),
@@ -132,7 +125,6 @@ func (m Model) handleDataMsg(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.statusMsg = "Config error: " + msg.err.Error()
 		}
 		m.cfg = msg.cfg
-		m.agents = msg.agents
 		m.projects = msg.projects
 		m.tags = msg.tags
 		if msg.cfg != nil {
@@ -189,9 +181,6 @@ func (m *Model) handlePaste(msg tea.PasteMsg) (tea.Model, tea.Cmd) {
 		m.updateModifyMatches(m.projects, m.tags)
 	case stateAnnotate:
 		m.annotateInput, cmd = m.annotateInput.Update(msg)
-	case stateRouteInput:
-		m.routeInput, cmd = m.routeInput.Update(msg)
-		m.updateRouteMatches()
 	}
 	return m, cmd
 }
@@ -209,7 +198,7 @@ func (m Model) View() tea.View {
 		content = m.viewTaskList()
 	case stateTaskDetail:
 		content = m.viewTaskDetail()
-	case stateRouteInput, stateModify, stateAnnotate, stateConfirmDelete:
+	case stateModify, stateAnnotate, stateConfirmDelete:
 		content = m.viewTaskList() // show list behind overlay
 	case stateHelp:
 		content = m.viewHelp()
@@ -219,8 +208,6 @@ func (m Model) View() tea.View {
 
 	// Overlays
 	switch m.state {
-	case stateRouteInput:
-		content = m.viewRouteOverlay(content)
 	case stateModify:
 		content = m.viewModifyOverlay(content)
 	case stateAnnotate:
@@ -238,8 +225,6 @@ func (m Model) View() tea.View {
 
 func (m *Model) handleKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
 	switch m.state {
-	case stateRouteInput:
-		return m.handleRouteKey(msg)
 	case stateSearch:
 		return m.handleSearchKey(msg)
 	case stateModify:
@@ -322,22 +307,6 @@ func (m *Model) handleAction(action keyAction) (tea.Model, tea.Cmd) {
 
 	// Global actions
 	switch action {
-	case keyRoute:
-		if len(m.filtered) > 0 {
-			t := m.selectedTask()
-			if t == nil {
-				break
-			}
-			// Auto-route to manager if one is configured
-			if manager := findAgentByRole(m.agents, "manager"); manager != nil {
-				return m, routeTask(t.UUID, manager.Name)
-			}
-			// Fallback: manual agent picker when no manager is configured
-			m.state = stateRouteInput
-			m.routeInput.SetValue("")
-			m.updateRouteMatches()
-			return m, m.routeInput.Focus()
-		}
 	case keyFilterNext:
 		m.filter = m.filter.Next()
 		m.cursor = 0
@@ -378,8 +347,8 @@ func (m *Model) handleTaskAction(action keyAction) tea.Cmd {
 		return cmd
 	}
 	switch action {
-	case keyExecute:
-		return executeTask(t.UUID)
+	case keyAdvance:
+		return advanceTask(t.UUID)
 	case keyAddToday:
 		return addToToday(t.UUID)
 	case keyRemoveToday:
@@ -597,51 +566,6 @@ func (m *Model) handleAnnotateKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
-func (m *Model) handleRouteKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
-	s := msg.String()
-	switch s {
-	case keyNameEnter:
-		m.routeInput.Blur()
-		if len(m.routeMatches) > 0 {
-			agent := m.routeMatches[0]
-			t := m.selectedTask()
-			if t != nil && agent.Role != "" {
-				m.state = stateTaskList
-				return m, routeTask(t.UUID, agent.Name)
-			}
-			if agent.Role == "" {
-				m.statusMsg = "Agent " + agent.Name + " has no role"
-			}
-		}
-		m.state = stateTaskList
-	case keyNameEsc:
-		m.routeInput.Blur()
-		m.state = stateTaskList
-	case keyNameTab:
-		if len(m.routeMatches) > 0 {
-			m.routeInput.SetValue(m.routeMatches[0].Name)
-			m.routeInput.CursorEnd()
-			m.updateRouteMatches()
-		}
-	default:
-		var cmd tea.Cmd
-		m.routeInput, cmd = m.routeInput.Update(msg)
-		m.updateRouteMatches()
-		return m, cmd
-	}
-	return m, nil
-}
-
-func (m *Model) updateRouteMatches() {
-	q := strings.ToLower(m.routeInput.Value())
-	m.routeMatches = nil
-	for _, a := range m.agents {
-		if q == "" || strings.Contains(strings.ToLower(a.Name), q) {
-			m.routeMatches = append(m.routeMatches, a)
-		}
-	}
-}
-
 func (m *Model) selectedTask() *Task {
 	if m.cursor >= 0 && m.cursor < len(m.filtered) {
 		return &m.filtered[m.cursor]
@@ -759,7 +683,6 @@ type autocompleteLoadedMsg struct {
 
 type configLoadedMsg struct {
 	cfg      *config.Config
-	agents   []agentfs.AgentInfo
 	projects []string
 	tags     []string
 	err      error
@@ -788,10 +711,6 @@ func loadConfig() tea.Cmd {
 		if err != nil {
 			return configLoadedMsg{err: fmt.Errorf("load config: %w", err)}
 		}
-		agents, err := agentfs.Discover(cfg.TeamPath())
-		if err != nil {
-			log.Printf("failed to discover agents: %v", err)
-		}
 
 		projects, err := taskwarrior.GetProjects()
 		if err != nil {
@@ -802,7 +721,7 @@ func loadConfig() tea.Cmd {
 			log.Printf("failed to load tags for autocomplete: %v", err)
 		}
 
-		return configLoadedMsg{cfg: cfg, agents: agents, projects: projects, tags: tags}
+		return configLoadedMsg{cfg: cfg, projects: projects, tags: tags}
 	}
 }
 
@@ -857,13 +776,3 @@ func loadTasks(filter filterMode, search string) tea.Cmd {
 		return tasksLoadedMsg{tasks: tasks}
 	}
 }
-
-// findAgentByRole returns the first agent with the given role, or nil.
-func findAgentByRole(agents []agentfs.AgentInfo, role string) *agentfs.AgentInfo {
-	for i := range agents {
-		if agents[i].Role == role {
-			return &agents[i]
-		}
-	}
-	return nil
-}
diff --git a/internal/tui/route_input.go b/internal/tui/route_input.go
index 1947cc35..086c3608 100644
--- a/internal/tui/route_input.go
+++ b/internal/tui/route_input.go
@@ -26,57 +26,6 @@ func (m Model) viewTextInputOverlay(background, title, prompt string, input text
 	return m.placeOverlay(background, overlay)
 }
 
-func (m Model) viewRouteOverlay(background string) string {
-	var b strings.Builder
-
-	b.WriteString(styleTitle.Render("Route to Agent"))
-	b.WriteString("\n\n")
-	b.WriteString("  ")
-	b.WriteString(m.routeInput.View())
-	b.WriteString("\n\n")
-
-	if len(m.routeMatches) == 0 {
-		b.WriteString(styleDim.Render("  No matching agents"))
-	} else {
-		for i, a := range m.routeMatches {
-			prefix := "  "
-			if i == 0 {
-				prefix = "> "
-			}
-			emoji := a.Emoji
-			if emoji == "" {
-				emoji = " "
-			}
-			var line string
-			if a.Role != "" {
-				role := styleDim.Render("(" + a.Role + ")")
-				line = fmt.Sprintf("%s%s %s %s", prefix, emoji, a.Name, role)
-			} else {
-				line = fmt.Sprintf("%s%s %s %s", prefix, emoji, a.Name, styleDim.Render("(no role)"))
-			}
-			if i == 0 {
-				line = styleSelected.Render(line)
-			} else if a.Role == "" {
-				line = styleDim.Render(line)
-			}
-			b.WriteString(line + "\n")
-			if i >= 9 {
-				b.WriteString(styleDim.Render(fmt.Sprintf("  ... and %d more", len(m.routeMatches)-10)))
-				break
-			}
-		}
-	}
-
-	b.WriteString("\n")
-	b.WriteString(styleDim.Render("  Enter:select  Tab:complete  Esc:cancel"))
-
-	overlay := styleOverlay.
-		Width(50).
-		Render(b.String())
-
-	return m.placeOverlay(background, overlay)
-}
-
 func (m Model) viewSearchOverlay(background string) string {
 	return m.viewModifyMatchesOverlay(
 		background, "Search Tasks",
diff --git a/internal/tui/state.go b/internal/tui/state.go
index 97fe6062..0347af41 100644
--- a/internal/tui/state.go
+++ b/internal/tui/state.go
@@ -5,7 +5,6 @@ type viewState int
 const (
 	stateTaskList viewState = iota
 	stateTaskDetail
-	stateRouteInput
 	stateSearch
 	stateModify
 	stateAnnotate
diff --git a/internal/tui/task_detail.go b/internal/tui/task_detail.go
index 4dc9eedf..1159d6fa 100644
--- a/internal/tui/task_detail.go
+++ b/internal/tui/task_detail.go
@@ -32,7 +32,7 @@ func (m Model) viewTaskDetail() string {
 
 	b.WriteString("\n")
 	b.WriteString(styleDim.Render(
-		"  x:execute  r:route  d:done  m:modify  A:annotate  o:PR  s:session  a:today  Esc:back"))
+		"  g:advance  d:done  m:modify  A:annotate  o:PR  s:session  a:today  Esc:back"))
 
 	return m.padToHeight(b.String()) + m.viewStatusBar()
 }
diff --git a/internal/watcher/jsonl.go b/internal/watcher/jsonl.go
index bd43f2b6..74c5959d 100644
--- a/internal/watcher/jsonl.go
+++ b/internal/watcher/jsonl.go
@@ -61,10 +61,10 @@ func refineBashTool(input json.RawMessage) string {
 	switch {
 	case strings.HasPrefix(cmd, "ttal send "):
 		return "ttal:send"
-	case strings.HasPrefix(cmd, "ttal task advance "),
+	case strings.HasPrefix(cmd, "ttal task go "),
 		strings.HasPrefix(cmd, "ttal task design "),
 		strings.HasPrefix(cmd, "ttal task research "):
-		// ttal task advance may block on Telegram approval gate; the daemon
+		// ttal task go may block on Telegram approval gate; the daemon
 		// handles output. No direct Telegram output from the CLI side.
 		return "ttal:route"
 	case strings.HasPrefix(cmd, "flicknote add "),
diff --git a/internal/watcher/watcher_test.go b/internal/watcher/watcher_test.go
index 7c5cf5a2..f719eafe 100644
--- a/internal/watcher/watcher_test.go
+++ b/internal/watcher/watcher_test.go
@@ -111,9 +111,9 @@ func TestExtractToolUse(t *testing.T) {
 			wantTool: "flicknote:write",
 		},
 		{
-			name: "Bash with ttal task advance",
+			name: "Bash with ttal task go",
 			line: `{"type":"assistant","message":{"content":` +
-				`[{"type":"tool_use","name":"Bash","id":"tu_9","input":{"command":"ttal task advance abc12345"}}]}}`,
+				`[{"type":"tool_use","name":"Bash","id":"tu_9","input":{"command":"ttal task go abc12345"}}]}}`,
 			wantTool: "ttal:route",
 		},
 		{
diff --git a/internal/worker/list.go b/internal/worker/list.go
index be8aba3a..6f2a659d 100644
--- a/internal/worker/list.go
+++ b/internal/worker/list.go
@@ -48,7 +48,7 @@ func List() error {
 	if len(tasks) == 0 {
 		fmt.Println("No active workers")
 		fmt.Println("\nTo spawn a worker:")
-		fmt.Println("  ttal task advance <uuid>")
+		fmt.Println("  ttal task go <uuid>")
 		return nil
 	}
 
diff --git a/internal/worker/spawn.go b/internal/worker/spawn.go
index 16058028..db7e19d1 100644
--- a/internal/worker/spawn.go
+++ b/internal/worker/spawn.go
@@ -29,7 +29,7 @@ type SpawnConfig struct {
 	Worktree bool
 	Force    bool
 	Runtime  runtime.Runtime
-	Spawner  string // team:agent format, set by ttal task advance
+	Spawner  string // team:agent format, set by ttal task go
 }
 
 // Spawn creates a new worker: validates task, sets up worktree, launches tmux session,
diff --git a/skills/ttal-task.md b/skills/ttal-task.md
index e3ff83d7..69496638 100644
--- a/skills/ttal-task.md
+++ b/skills/ttal-task.md
@@ -37,8 +37,8 @@ ttal task find <keyword> --completed   # search completed tasks
 Move a task to the next pipeline stage (routes to agent or spawns worker based on config).
 
 ```bash
-ttal task advance <uuid>                         # advance to next pipeline stage
+ttal task go <uuid>                         # advance to next pipeline stage
 ```
 
 **When to use:**
-- `ttal task advance` — moves the task through the configured pipeline: routes to the right agent for design/review stages, or spawns a worker for implementation stages. Gate type (auto/human) is determined by the pipeline config.
+- `ttal task go` — moves the task through the configured pipeline: routes to the right agent for design/review stages, or spawns a worker for implementation stages. Gate type (auto/human) is determined by the pipeline config.
diff --git a/templates/basic/README.md b/templates/basic/README.md
index 3e1de142..9827e3cb 100644
--- a/templates/basic/README.md
+++ b/templates/basic/README.md
@@ -20,7 +20,7 @@ You create a task
   → manager routes it: ttal task design <uuid>
   → designer writes an implementation plan
   → you approve
-  → manager spawns a worker: ttal task advance <uuid>
+  → manager spawns a worker: ttal task go <uuid>
   → worker executes the plan, creates a PR
 ```
 
diff --git a/templates/basic/manager.md b/templates/basic/manager.md
index 08d07964..5e6e058b 100644
--- a/templates/basic/manager.md
+++ b/templates/basic/manager.md
@@ -13,7 +13,7 @@ You are the task manager for this team. You organize work, route tasks to the ri
 ## Your Role
 
 - Manage tasks via taskwarrior: create, prioritize, tag, schedule
-- Route tasks to agents: `ttal task design` for planning, `ttal task execute` for implementation
+- Route tasks to agents: `ttal task design` for planning, `ttal task go` for implementation
 - Maintain the daily focus list with `ttal today`
 - Respond to human messages and status requests
 - Monitor worker progress via `ttal worker list`
@@ -24,7 +24,7 @@ When a new task comes in:
 1. Read it: `ttal task get <uuid>`
 2. Decide what it needs:
    - Needs a plan? → `ttal task design <uuid>`
-   - Ready to execute? → `ttal task advance <uuid>` (only after human approval)
+   - Ready to execute? → `ttal task go <uuid>` (only after human approval)
 3. Track progress and report status
 
 When the human asks "what's happening?":
@@ -45,7 +45,7 @@ ttal task get <uuid>         # Full task details
 ## Decision Rules
 
 - **Do freely:** Read tasks, update priorities, manage daily focus, route to design agent
-- **Ask first:** Spawning workers (`ttal task execute`), closing tasks as done
+- **Ask first:** Spawning workers (`ttal task go`), closing tasks as done
 - **Never do:** Write code, edit source files, make architectural decisions
 
 ## Git Commits
diff --git a/templates/docs/agents/plan-reviewer.md b/templates/docs/agents/plan-reviewer.md
index e724b8c1..5d0558fa 100644
--- a/templates/docs/agents/plan-reviewer.md
+++ b/templates/docs/agents/plan-reviewer.md
@@ -171,7 +171,7 @@ If the plan needs work:
 ttal task comment <uuid> "Needs revision: <specific feedback>" --verdict needs_work
 ```
 
-The `--verdict lgtm` flag adds the `+lgtm` tag to the task, which signals the pipeline engine that the review gate is satisfied. Without it, `ttal task advance` will block waiting for the reviewer's verdict.
+The `--verdict lgtm` flag adds the `+lgtm` tag to the task, which signals the pipeline engine that the review gate is satisfied. Without it, `ttal task go` will block waiting for the reviewer's verdict.
 
 ## Rules
 
diff --git a/templates/docs/commands/breathe.md b/templates/docs/commands/breathe.md
index 4828742e..4b463f6d 100644
--- a/templates/docs/commands/breathe.md
+++ b/templates/docs/commands/breathe.md
@@ -81,7 +81,7 @@ Your handoff is saved in diary — it persists across sessions.
 
 ## Auto-Breathe on Route
 
-When a task is routed via `ttal task route`, the agent is asked to breathe
+When a task is routed via `ttal task go`, the agent is asked to breathe
 so they start fresh. The router stages routing params to
 `~/.ttal/routing/<agent>.json`, then sends a message asking the agent to
 `/breathe`. The daemon composes the restart:
@@ -91,7 +91,7 @@ so they start fresh. The router stages routing params to
 
 Managers are exempt — they keep persistent sessions.
 
-To skip: `ttal task advance <uuid> --no-breathe`
+To skip: `ttal task go <uuid> --no-breathe`
 
 ## Unified Spawn Pattern
 
diff --git a/templates/docs/commands/plan-review.md b/templates/docs/commands/plan-review.md
index ed48dee8..5f750405 100644
--- a/templates/docs/commands/plan-review.md
+++ b/templates/docs/commands/plan-review.md
@@ -54,7 +54,7 @@ Then show each plan's full review below the table.
 ## After Review
 
 Present the verdict and let Neil or the routing agent decide:
-- **Ready** — plan can proceed to `ttal task execute`
+- **Ready** — plan can proceed to `ttal task go`
 - **Needs revision** — use `/plan-triage` to categorize and fix issues, or route back to the design agent
 - **Needs rethink** — plan has fundamental problems, needs brainstorming first
 
diff --git a/templates/docs/skills/sp-debugging/SKILL.md b/templates/docs/skills/sp-debugging/SKILL.md
index cc918a04..4007d580 100644
--- a/templates/docs/skills/sp-debugging/SKILL.md
+++ b/templates/docs/skills/sp-debugging/SKILL.md
@@ -186,7 +186,7 @@ task <uuid> annotate 'Fix plan: flicknote <hex-id>'
 3. **Annotate the task** with plan reference (inline or flicknote hex ID)
 4. **Tag as planned:** `task <uuid> modify -bugfix +planned`
 5. **Review:** Run at least 1 round of `/plan-review <flicknote-id>`. Revise if needed.
-6. **Execute:** When the plan passes review, run `ttal task advance <uuid>` to spawn a worker.
+6. **Execute:** When the plan passes review, run `ttal task go <uuid>` to spawn a worker.
 
 ## Red Flags — STOP and Return to Phase 1
 
diff --git a/templates/docs/skills/sp-writing-plans/SKILL.md b/templates/docs/skills/sp-writing-plans/SKILL.md
index ca45a176..7994c882 100644
--- a/templates/docs/skills/sp-writing-plans/SKILL.md
+++ b/templates/docs/skills/sp-writing-plans/SKILL.md
@@ -169,7 +169,7 @@ task <uuid> annotate 'Plan: flicknote <hex-id>'
 3. **Annotate the task** with plan reference (inline or flicknote hex ID)
 4. **Tag as planned:** `task <uuid> modify +planned`
 5. **Review:** Run at least 2 rounds of `/plan-review <flicknote-id>`. Revise until the plan passes.
-6. **Execute:** When the plan survives review, run `ttal task advance <uuid>` to spawn a worker.
+6. **Execute:** When the plan survives review, run `ttal task go <uuid>` to spawn a worker.
 
 ## Remember
 
diff --git a/templates/full-flicknote/compass.md b/templates/full-flicknote/compass.md
index 9a8be7d8..eb47afe4 100644
--- a/templates/full-flicknote/compass.md
+++ b/templates/full-flicknote/compass.md
@@ -18,7 +18,7 @@ A compass doesn't move — it orients. You read the field, find north, and point
 ## Your Role
 
 - Manage tasks via taskwarrior: create, prioritize, tag, schedule
-- Route tasks: `ttal task design` → ink, `ttal task research` → owl, `ttal task execute` → hawk spawns worker
+- Route tasks: `ttal task design` → ink, `ttal task research` → owl, `ttal task go` → hawk spawns worker
 - Maintain daily focus with `ttal today`
 - Respond to human messages — concise status, clear next steps
 - Monitor team health: who's working on what, what's blocked
diff --git a/templates/full-markdown/README.md b/templates/full-markdown/README.md
index 78da9e34..04b81512 100644
--- a/templates/full-markdown/README.md
+++ b/templates/full-markdown/README.md
@@ -23,7 +23,7 @@ task add "Build feature X" +research
   → task moves to +design
   → designer writes plan to docs/plans/
   → you approve
-  → manager spawns a worker: ttal task advance <uuid>
+  → manager spawns a worker: ttal task go <uuid>
   → worker executes, creates PR
   → reviewer checks PR, worker triages feedback
 
diff --git a/templates/full-markdown/manager.md b/templates/full-markdown/manager.md
index 08d07964..5e6e058b 100644
--- a/templates/full-markdown/manager.md
+++ b/templates/full-markdown/manager.md
@@ -13,7 +13,7 @@ You are the task manager for this team. You organize work, route tasks to the ri
 ## Your Role
 
 - Manage tasks via taskwarrior: create, prioritize, tag, schedule
-- Route tasks to agents: `ttal task design` for planning, `ttal task execute` for implementation
+- Route tasks to agents: `ttal task design` for planning, `ttal task go` for implementation
 - Maintain the daily focus list with `ttal today`
 - Respond to human messages and status requests
 - Monitor worker progress via `ttal worker list`
@@ -24,7 +24,7 @@ When a new task comes in:
 1. Read it: `ttal task get <uuid>`
 2. Decide what it needs:
    - Needs a plan? → `ttal task design <uuid>`
-   - Ready to execute? → `ttal task advance <uuid>` (only after human approval)
+   - Ready to execute? → `ttal task go <uuid>` (only after human approval)
 3. Track progress and report status
 
 When the human asks "what's happening?":
@@ -45,7 +45,7 @@ ttal task get <uuid>         # Full task details
 ## Decision Rules
 
 - **Do freely:** Read tasks, update priorities, manage daily focus, route to design agent
-- **Ask first:** Spawning workers (`ttal task execute`), closing tasks as done
+- **Ask first:** Spawning workers (`ttal task go`), closing tasks as done
 - **Never do:** Write code, edit source files, make architectural decisions
 
 ## Git Commits
diff --git a/templates/ttal/astra.md b/templates/ttal/astra.md
index 9f34f45c..c00a689d 100644
--- a/templates/ttal/astra.md
+++ b/templates/ttal/astra.md
@@ -45,12 +45,12 @@ I'm part of an agent system running on **Claude Code**:
 
 **Turn research and requirements into executable implementation plans.**
 
-I save plans via `flicknote add 'plan content' --project fn.plans` (title auto-generated), then create a task via `ttal task add` with the flicknote hex ID. Execution is handled by `ttal task advance <uuid>`.
+I save plans via `flicknote add 'plan content' --project fn.plans` (title auto-generated), then create a task via `ttal task add` with the flicknote hex ID. Execution is handled by `ttal task go <uuid>`.
 
 ### The Pipeline
 
 ```
-Nyx researches → Astra writes plan → ttal task add → ttal task advance → Worker executes
+Nyx researches → Astra writes plan → ttal task add → ttal task go → Worker executes
 ```
 
 ### What I Own
@@ -72,7 +72,7 @@ Run `ttal skill get sp-writing-plans` when writing plans for plan format, qualit
 
 **My flicknote project:** `fn.plans`
 
-**Plans are immutable once a worker starts executing them.** Never modify a plan after `ttal task advance` has been run. Write a new plan instead.
+**Plans are immutable once a worker starts executing them.** Never modify a plan after `ttal task go` has been run. Write a new plan instead.
 
 ## Decision Rules
 
@@ -85,7 +85,7 @@ Run `ttal skill get sp-writing-plans` when writing plans for plan format, qualit
 - Write diary entries (`diary astra append "..."`)
 
 ### Collaborative (Neil approves)
-- **Executing tasks** — run at least 2 rounds of `/plan-review` first. When the plan survives review and you're confident, run `ttal task advance <uuid>`.
+- **Executing tasks** — run at least 2 rounds of `/plan-review` first. When the plan survives review and you're confident, run `ttal task go <uuid>`.
 - Architecture decisions that affect multiple projects
 - Plans involving breaking changes or migrations
 - When trade-offs are genuinely close
diff --git a/templates/ttal/cael.md b/templates/ttal/cael.md
index 277764b9..e80a5cff 100644
--- a/templates/ttal/cael.md
+++ b/templates/ttal/cael.md
@@ -78,7 +78,7 @@ I'm part of an agent system running on **Claude Code**:
 - Update memory with infrastructure patterns and lessons
 
 ### Collaborative (Neil approves)
-- **Executing tasks** — run at least 2 rounds of `/plan-review` first. When the plan survives review and you're confident, run `ttal task advance <uuid>`.
+- **Executing tasks** — run at least 2 rounds of `/plan-review` first. When the plan survives review and you're confident, run `ttal task go <uuid>`.
 - Architecture decisions that affect multiple projects
 - Plans involving breaking changes, migrations, or production
 - Cross-project infrastructure changes
diff --git a/templates/ttal/inke.md b/templates/ttal/inke.md
index 581cb32f..fff4b36c 100644
--- a/templates/ttal/inke.md
+++ b/templates/ttal/inke.md
@@ -45,12 +45,12 @@ I save plans via `flicknote add 'plan content' --project ttal.plans` (title auto
 ### The Pipeline
 
 ```
-Athena researches → Inke writes plan → flicknote + task + annotate → ttal task advance → Worker executes
+Athena researches → Inke writes plan → flicknote + task + annotate → ttal task go → Worker executes
 ```
 
 Sometimes I work from Athena's research docs. Sometimes Neil gives me a direct requirement. Either way, the output is the same: a plan clear enough for a worker to execute without guessing.
 
-**Task lifecycle:** Save plan to flicknote, create task (if one doesn't exist) via `ttal task add`, annotate with hex ID, then run `ttal task advance <uuid>` to spawn a worker.
+**Task lifecycle:** Save plan to flicknote, create task (if one doesn't exist) via `ttal task add`, annotate with hex ID, then run `ttal task go <uuid>` to spawn a worker.
 
 **Repo path annotations:** When a plan references specific code repos, annotate the task with their full absolute paths (e.g. `task $uuid annotate "repo: /Users/neil/Code/guion/flick-backend-31/workers"`). Workers need exact paths to find the code.
 
@@ -85,7 +85,7 @@ Run `ttal skill get sp-writing-plans` when writing plans for plan format, qualit
 - Update memory files
 
 ### Collaborative (Neil approves)
-- **Executing tasks** — run at least 2 rounds of `/plan-review` first. When the plan survives review and you're confident, run `ttal task advance <uuid>`.
+- **Executing tasks** — run at least 2 rounds of `/plan-review` first. When the plan survives review and you're confident, run `ttal task go <uuid>`.
 - Architecture decisions that affect multiple projects
 - Plans that involve breaking changes or migrations
 - When trade-offs are genuinely close and I can't recommend confidently
@@ -171,7 +171,7 @@ Follow the "When Design Is Finished" workflow in sp-writing-plans. Use project `
 
 - Don't write plans without reading the actual codebase first — assumptions kill plans
 - Don't create separate execution tasks — use single-task lifecycle (tag swap)
-- **Never write code, edit source files, run builds, or commit in project repos** — I plan, workers execute. When asked to "execute the task", use `ttal task advance $uuid` which spawns a worker in its own tmux session + git worktree.
+- **Never write code, edit source files, run builds, or commit in project repos** — I plan, workers execute. When asked to "execute the task", use `ttal task go $uuid` which spawns a worker in its own tmux session + git worktree.
 - When a plan has risky steps (migrations, breaking changes), flag them explicitly
 - If research is insufficient, ask for more rather than guessing
 - One plan per session — depth over breadth
diff --git a/templates/ttal/kestrel.md b/templates/ttal/kestrel.md
index ab5db0a5..2a0eb894 100644
--- a/templates/ttal/kestrel.md
+++ b/templates/ttal/kestrel.md
@@ -40,15 +40,15 @@ I'm part of an agent system running on **Claude Code**:
 
 **Diagnose bugs and write fix plans for workers to execute.**
 
-I save fix plans via `flicknote add 'plan content' --project ttal.fixes` (title auto-generated), then run `ttal task advance <uuid>` to spawn a worker.
+I save fix plans via `flicknote add 'plan content' --project ttal.fixes` (title auto-generated), then run `ttal task go <uuid>` to spawn a worker.
 
 ### The Pipeline
 
 ```
-Bug report → Kestrel investigates → fix plan → flicknote + task + annotate → ttal task advance → Worker executes
+Bug report → Kestrel investigates → fix plan → flicknote + task + annotate → ttal task go → Worker executes
 ```
 
-**Task lifecycle:** Investigate the bug, save fix plan to flicknote, create task (if one doesn't exist) via `ttal task add`, annotate with hex ID, then run `ttal task advance <uuid>` to spawn a worker.
+**Task lifecycle:** Investigate the bug, save fix plan to flicknote, create task (if one doesn't exist) via `ttal task add`, annotate with hex ID, then run `ttal task go <uuid>` to spawn a worker.
 
 **Finding the project:** When Neil sends an error log without specifying which project, use `ttal project list` and `ttal project get <alias>` to identify the right codebase from clues in the error (package names, file paths, service names). Don't guess — look it up.
 
@@ -83,7 +83,7 @@ Bug report → Kestrel investigates → fix plan → flicknote + task + annotate
 - Update memory files
 
 ### Collaborative (Neil approves)
-- **Executing tasks** — run at least 1 round of `/plan-review` first. When the plan passes review, run `ttal task advance <uuid>`.
+- **Executing tasks** — run at least 1 round of `/plan-review` first. When the plan passes review, run `ttal task go <uuid>`.
 - Fixes that involve breaking changes or migrations
 - When a bug fix reveals a deeper architectural issue that needs Inke's input
 
@@ -164,7 +164,7 @@ Follow the "After the Fix Plan Is Written" workflow in sp-debugging.
 
 - Don't write fix plans without reading the actual codebase first — guessed root causes waste time
 - Don't create separate execution tasks — use single-task lifecycle
-- **Never write code, edit source files, run builds, or commit in project repos** — I plan, workers execute. When asked to "execute the task", use `ttal task advance $uuid` which spawns a worker in its own tmux session + git worktree.
+- **Never write code, edit source files, run builds, or commit in project repos** — I plan, workers execute. When asked to "execute the task", use `ttal task go $uuid` which spawns a worker in its own tmux session + git worktree.
 - When a fix has risky steps (migrations, data changes), flag them explicitly
 - If the bug can't be reproduced, say so — don't guess at fixes for phantom bugs
 - One fix plan per session — depth over breadth
diff --git a/templates/ttal/lux.md b/templates/ttal/lux.md
index d01068f4..9220f75e 100644
--- a/templates/ttal/lux.md
+++ b/templates/ttal/lux.md
@@ -46,17 +46,17 @@ I'm part of an agent system running on **Claude Code**:
 
 **Diagnose bugs and write fix plans for workers to execute.**
 
-I save fix plans via `flicknote add 'plan content' --project fn.fixes` (title auto-generated), then run `ttal task advance <uuid>` to spawn a worker.
+I save fix plans via `flicknote add 'plan content' --project fn.fixes` (title auto-generated), then run `ttal task go <uuid>` to spawn a worker.
 
 ### The Pipeline
 
 ```
-Bug report → Lux diagnoses → fix plan → flicknote + task + annotate → ttal task advance → Worker executes
+Bug report → Lux diagnoses → fix plan → flicknote + task + annotate → ttal task go → Worker executes
 ```
 
 Sometimes I get a detailed bug report with stack traces. Sometimes Neil just pastes an error log directly. Either way, the output is the same: a diagnosis that identifies the root cause and a fix plan clear enough for a worker to execute without guessing.
 
-**Task lifecycle:** Investigate the bug, save fix plan to flicknote, create task (if one doesn't exist) via `ttal task add`, annotate with hex ID, then run `ttal task advance <uuid>` to spawn a worker.
+**Task lifecycle:** Investigate the bug, save fix plan to flicknote, create task (if one doesn't exist) via `ttal task add`, annotate with hex ID, then run `ttal task go <uuid>` to spawn a worker.
 
 **Finding the project:** When Neil sends an error log without specifying which project, use `ttal project list` and `ttal project get <alias>` to identify the right codebase from clues in the error (package names, file paths, service names). Don't guess — look it up.
 
@@ -92,7 +92,7 @@ Run `ttal skill get sp-debugging` for the full workflow: diagnosis methodology,
 - Update memory files
 
 ### Collaborative (Neil approves)
-- **Executing tasks** — run at least 1 round of `/plan-review` first. When the plan passes review, run `ttal task advance <uuid>`.
+- **Executing tasks** — run at least 1 round of `/plan-review` first. When the plan passes review, run `ttal task go <uuid>`.
 - Fixes that involve breaking changes or migrations
 - When a bug fix reveals a deeper architectural issue that needs a designer's input
 
@@ -177,7 +177,7 @@ Follow the "After the Fix Plan Is Written" workflow in sp-debugging. Use project
 
 - Don't write fix plans without reading the actual codebase first — guessed root causes waste time
 - Don't create separate execution tasks — use single-task lifecycle
-- **Never write code, edit source files, run builds, or commit in project repos** — I plan, workers execute. When asked to "execute the task", use `ttal task advance $uuid` which spawns a worker in its own tmux session + git worktree.
+- **Never write code, edit source files, run builds, or commit in project repos** — I plan, workers execute. When asked to "execute the task", use `ttal task go $uuid` which spawns a worker in its own tmux session + git worktree.
 - When a fix has risky steps (migrations, data changes), flag them explicitly
 - If the bug can't be reproduced, say so — don't guess at fixes for phantom bugs
 - One fix plan per session — depth over breadth
diff --git a/templates/ttal/mira.md b/templates/ttal/mira.md
index 7012be24..d6448f61 100644
--- a/templates/ttal/mira.md
+++ b/templates/ttal/mira.md
@@ -46,12 +46,12 @@ I'm part of an agent system running on **Claude Code**:
 
 **Turn research and requirements into executable implementation plans for Guion/fb3 projects.**
 
-I save plans via `flicknote add 'plan content' --project fn.plans` (title auto-generated), then create a task via `ttal task add` with the flicknote hex ID. Execution is handled by `ttal task advance <uuid>`.
+I save plans via `flicknote add 'plan content' --project fn.plans` (title auto-generated), then create a task via `ttal task add` with the flicknote hex ID. Execution is handled by `ttal task go <uuid>`.
 
 ### The Pipeline
 
 ```
-Nyx researches → Mira writes plan → ttal task add → ttal task advance → Worker executes
+Nyx researches → Mira writes plan → ttal task add → ttal task go → Worker executes
 ```
 
 ### What I Own
@@ -74,7 +74,7 @@ Run `ttal skill get sp-writing-plans` when writing plans for plan format, qualit
 
 **My flicknote project:** `fn.plans`
 
-**Plans are immutable once a worker starts executing them.** Never modify a plan after `ttal task advance` has been run. Write a new plan instead.
+**Plans are immutable once a worker starts executing them.** Never modify a plan after `ttal task go` has been run. Write a new plan instead.
 
 ## Decision Rules
 
@@ -88,7 +88,7 @@ Run `ttal skill get sp-writing-plans` when writing plans for plan format, qualit
 - Update memory files
 
 ### Collaborative (Neil approves)
-- **Executing tasks** — run at least 2 rounds of `/plan-review` first. When the plan survives review and you're confident, run `ttal task advance <uuid>`.
+- **Executing tasks** — run at least 2 rounds of `/plan-review` first. When the plan survives review and you're confident, run `ttal task go <uuid>`.
 - Architecture decisions that affect multiple projects
 - Plans involving breaking changes or migrations
 - When trade-offs are genuinely close
@@ -170,7 +170,7 @@ Follow the "When Design Is Finished" workflow in sp-writing-plans. Use project `
 
 - Don't write plans without reading the actual codebase first — assumptions kill plans
 - Don't create tasks via raw `task add` — use `ttal task add` instead
-- **Never write code, edit source files, run builds, or commit in project repos** — I plan, workers execute. When asked to "execute the task", use `ttal task advance $uuid` which spawns a worker in its own tmux session + git worktree.
+- **Never write code, edit source files, run builds, or commit in project repos** — I plan, workers execute. When asked to "execute the task", use `ttal task go $uuid` which spawns a worker in its own tmux session + git worktree.
 - When a plan has risky steps (migrations, breaking changes), flag them explicitly
 - One plan per session — depth over breadth
 
diff --git a/templates/ttal/yuki.md b/templates/ttal/yuki.md
index 408d496b..a3eec2b7 100644
--- a/templates/ttal/yuki.md
+++ b/templates/ttal/yuki.md
@@ -28,7 +28,7 @@ I'm the **task orchestrator**. I create, route, and manage all work via taskwarr
 **Task creation:** Use `ttal task add --project <alias> "description"` for creating tasks. Supports `--tag`, `--priority`, `--annotate` flags. Run `ttal skill get ttal-cli` at session start for up-to-date commands.
 - **task-deleter** subagent — task deletion (single or bulk). Use `Task` tool with `subagent_type: "task-deleter"`. Give it UUIDs, keywords, or descriptions — it handles resolution and safe deletion.
 
-**Task routing:** Use `/ttal-route <uuid>` to classify a task's readiness and route directly. `ttal task advance <uuid>` is the single command that replaces route + execute — it advances a task through pipeline stages (routes to agent or spawns worker based on `pipelines.toml`). Has a built-in human gate. Tasks move through stages in order — `ask → brainstorm → research/design → execute` — don't skip.
+**Task routing:** Use `/ttal-route <uuid>` to classify a task's readiness and route directly. `ttal task go <uuid>` is the single command that replaces route + execute — it advances a task through pipeline stages (routes to agent or spawns worker based on `pipelines.toml`). Has a built-in human gate. Tasks move through stages in order — `ask → brainstorm → research/design → execute` — don't skip.
 
 **Heartbeat:** The daemon fires my `heartbeat_prompt` every hour (configured via `heartbeat_interval = "1h"` in config.toml under `[teams.default.agents.yuki]`). On each heartbeat, I run `ttal today list`, pick a task, and apply `ttal-route` to advance it. Timer resets on daemon restart — no persistence needed.
 
@@ -110,9 +110,7 @@ task active                        # Currently working
 
 **Task routing** — use ttal commands to route tasks, not `task start` or `ttal send`:
 ```bash
-ttal task advance <uuid>          # route to any agent (Inke, Athena, etc.)
-ttal task advance <uuid> --message "context"   # with optional context
-ttal task advance <uuid>                     # spawn a worker — creates tmux session + git worktree
+ttal task go <uuid>          # advance to next pipeline stage (routes to agent or spawns worker)
 ```
 
 **Dependencies:**
@@ -138,9 +136,9 @@ ttal task advance <uuid>                     # spawn a worker — creates tmux s
 **Routing workflow — use `/ttal-route <uuid>` to classify, then act:**
 - Too vague → ask Neil, tag `+ask`
 - Clear goal, no design → brainstorm
-- Needs investigation → `ttal task advance <uuid>`
-- Needs a plan → `ttal task advance <uuid>`
-- Plan/research annotated → `ttal task advance <uuid>` → spawns worker in tmux + worktree
+- Needs investigation → `ttal task go <uuid>`
+- Needs a plan → `ttal task go <uuid>`
+- Plan/research annotated → `ttal task go <uuid>` → spawns worker in tmux + worktree
 
 **Routing style:** Be conversational, use agent emojis, give Neil a brief take on the task and offer alternatives when reasonable.