diff --git a/backend/src/index.ts b/backend/src/index.ts
index b7b9409cd..67a0b450c 100644
--- a/backend/src/index.ts
+++ b/backend/src/index.ts
@@ -340,7 +340,7 @@ app.route('/api/auth-info', createAuthInfoRoutes(auth, db))
 app.route('/api/health', createHealthRoutes(db, openCodeSupervisor))
 
 app.route('/api/mcp-oauth-proxy', createMcpOauthProxyRoutes(openCodeClient, requireAuth))
-app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, sessionPermissionModeService, repoWorkspaces, gitAuthService))
+app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, sessionPermissionModeService, repoWorkspaces, gitAuthService, sessionGoalService, multiRunService))
 app.route('/api/opencode-proxy', createOpenCodeProxyRoutes(db, settingsService))
 
 const protectedApi = new Hono()
diff --git a/backend/src/routes/internal/index.ts b/backend/src/routes/internal/index.ts
index 346b9414e..4ca67c54e 100644
--- a/backend/src/routes/internal/index.ts
+++ b/backend/src/routes/internal/index.ts
@@ -17,9 +17,13 @@ import { createInternalSessionRoutes } from './sessions'
 import { createInternalAssistantRoutes } from './assistant'
 import { createInternalGitCredentialsRoutes } from './git-credentials'
 import { createInternalSandboxRoutes } from './sandbox'
+import { createSessionGoalRoutes } from '../session-goals'
+import { createMultiRunRoutes } from '../multi-runs'
 import type { SessionPermissionModeService } from '../../services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../services/repo-workspace'
 import type { GitAuthService } from '../../services/git-auth'
+import type { SessionGoalService } from '../../services/session-goals'
+import type { MultiRunService } from '../../services/multi-runs'
 
 export function createInternalRoutes(
   db: Database,
@@ -30,10 +34,14 @@ export function createInternalRoutes(
   permissionModes: SessionPermissionModeService,
   repoWorkspaces: RepoWorkspaceService,
   gitAuthService: GitAuthService,
+  sessionGoals: SessionGoalService,
+  multiRuns: MultiRunService,
 ) {
   const app = new Hono()
   app.use('/*', createInternalTokenMiddleware(db))
   app.route('/schedules', createScheduleRoutes(scheduleService))
+  app.route('/session-goals', createSessionGoalRoutes(sessionGoals))
+  app.route('/multi-runs', createMultiRunRoutes(multiRuns))
   app.route('/notifications', createInternalNotificationRoutes(notificationService))
   app.route('/settings', createInternalSettingsRoutes(settingsService))
   app.route('/opencode-config', createOpenCodeConfigRoutes(settingsService, openCodeClient, { redactSecrets: true }))
diff --git a/backend/test/routes/internal-assistant.test.ts b/backend/test/routes/internal-assistant.test.ts
index ea4bc953a..4c91a790e 100644
--- a/backend/test/routes/internal-assistant.test.ts
+++ b/backend/test/routes/internal-assistant.test.ts
@@ -2,6 +2,8 @@ import { describe, it, expect, beforeEach, vi } from 'vitest'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import { Hono } from 'hono'
 import { Database } from 'bun:sqlite'
 import { createInternalRoutes } from '../../src/routes/internal'
@@ -46,7 +48,7 @@ describe('internal/assistant routes', () => {
     notificationService = new NotificationService(db)
     settingsService = new SettingsService(db)
     app = new Hono()
-    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
     token = getOrCreateInternalToken(db)
   })
 
diff --git a/backend/test/routes/internal-multi-runs.test.ts b/backend/test/routes/internal-multi-runs.test.ts
new file mode 100644
index 000000000..06a830365
--- /dev/null
+++ b/backend/test/routes/internal-multi-runs.test.ts
@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
+import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
+import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
+import { Hono } from 'hono'
+import { Database } from 'bun:sqlite'
+import { createInternalRoutes } from '../../src/routes/internal'
+import type { ScheduleService } from '../../src/services/schedules'
+import type { NotificationService } from '../../src/services/notification'
+import type { SettingsService } from '../../src/services/settings'
+import type { OpenCodeClient } from '../../src/services/opencode/client'
+import { allMigrations } from '../../src/db/migrations'
+import { getOrCreateInternalToken } from '../../src/services/internal-token'
+import { migrate } from '../../src/db/migration-runner'
+
+function createMultiRunStub() {
+  return {
+    list: vi.fn(),
+    launch: vi.fn(),
+    discard: vi.fn(),
+    fuse: vi.fn(),
+  }
+}
+
+function createRun(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 1,
+    repoId: 1,
+    name: 'Sweep',
+    prompt: 'go',
+    isolated: true,
+    baseRef: null,
+    createdAt: 1,
+    entries: [],
+    fusions: [],
+    ...overrides,
+  }
+}
+
+function fuseBody(overrides: Record<string, unknown> = {}) {
+  return {
+    requestId: '11111111-1111-4111-8111-111111111111',
+    entryIds: [1, 2],
+    model: 'openai/a',
+    ...overrides,
+  }
+}
+
+describe('internal-multi-runs routes', () => {
+  let db: Database
+  let multiRuns: ReturnType<typeof createMultiRunStub>
+  let app: Hono
+  let token: string
+
+  beforeEach(() => {
+    db = new Database(':memory:')
+    migrate(db, allMigrations)
+    multiRuns = createMultiRunStub()
+    app = new Hono()
+    app.route(
+      '/api/internal',
+      createInternalRoutes(
+        db,
+        {} as ScheduleService,
+        {} as NotificationService,
+        {} as SettingsService,
+        {} as OpenCodeClient,
+        {} as SessionPermissionModeService,
+        {} as unknown as RepoWorkspaceService,
+        {} as unknown as GitAuthService,
+        {} as unknown as SessionGoalService,
+        multiRuns as unknown as MultiRunService,
+      ),
+    )
+    token = getOrCreateInternalToken(db)
+  })
+
+  it('GET /api/internal/multi-runs returns 401 without bearer token', async () => {
+    const res = await app.request('/api/internal/multi-runs?repoId=1')
+    expect(res.status).toBe(401)
+  })
+
+  it('GET /api/internal/multi-runs returns the repository runs with a bearer token', async () => {
+    multiRuns.list.mockReturnValue([])
+
+    const res = await app.request('/api/internal/multi-runs?repoId=1', {
+      headers: { authorization: `Bearer ${token}` },
+    })
+
+    expect(res.status).toBe(200)
+    await expect(res.json()).resolves.toEqual({ runs: [] })
+    expect(multiRuns.list).toHaveBeenCalledWith(1)
+  })
+
+  it('POST /api/internal/multi-runs/3/entries/4/discard discards the entry', async () => {
+    multiRuns.discard.mockResolvedValue(createRun())
+
+    const res = await app.request('/api/internal/multi-runs/3/entries/4/discard', {
+      method: 'POST',
+      headers: { authorization: `Bearer ${token}` },
+    })
+
+    expect(res.status).toBe(200)
+    expect(multiRuns.discard).toHaveBeenCalledWith(3, 4)
+  })
+
+  it('POST /api/internal/multi-runs/3/fusions fuses the run', async () => {
+    multiRuns.fuse.mockResolvedValue({ run: createRun(), created: true })
+    const body = fuseBody()
+
+    const res = await app.request('/api/internal/multi-runs/3/fusions', {
+      method: 'POST',
+      headers: { authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+
+    expect(res.status).toBe(201)
+    await expect(res.json()).resolves.toEqual({ run: createRun() })
+    expect(multiRuns.fuse).toHaveBeenCalledWith(3, body)
+  })
+})
diff --git a/backend/test/routes/internal-notifications.test.ts b/backend/test/routes/internal-notifications.test.ts
index 36b90f237..701f806b7 100644
--- a/backend/test/routes/internal-notifications.test.ts
+++ b/backend/test/routes/internal-notifications.test.ts
@@ -2,6 +2,8 @@ import { describe, it, expect, beforeEach, vi } from 'bun:test'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import { Hono } from 'hono'
 import { Database } from 'bun:sqlite'
 import { createInternalRoutes } from '../../src/routes/internal'
@@ -32,7 +34,7 @@ describe('internal/notifications routes', () => {
     notificationService = new NotificationService(db)
     settingsService = new SettingsService(db)
     app = new Hono()
-    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
     token = getOrCreateInternalToken(db)
   })
 
diff --git a/backend/test/routes/internal-opencode-config.test.ts b/backend/test/routes/internal-opencode-config.test.ts
index 01170e5b5..dfcbec4d2 100644
--- a/backend/test/routes/internal-opencode-config.test.ts
+++ b/backend/test/routes/internal-opencode-config.test.ts
@@ -2,6 +2,8 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'bun:test'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import { Hono } from 'hono'
 import { Database } from 'bun:sqlite'
 import { readFile, writeFile } from 'fs/promises'
@@ -62,7 +64,7 @@ describe('internal/opencode-config routes', () => {
     const notificationService = new NotificationService(db)
     const settingsService = new SettingsService(db)
     app = new Hono()
-    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
     token = getOrCreateInternalToken(db)
   })
 
diff --git a/backend/test/routes/internal-opencode-workspaces.test.ts b/backend/test/routes/internal-opencode-workspaces.test.ts
index d302cd97a..738f76e14 100644
--- a/backend/test/routes/internal-opencode-workspaces.test.ts
+++ b/backend/test/routes/internal-opencode-workspaces.test.ts
@@ -2,6 +2,8 @@ import { describe, it, expect, beforeEach, vi } from 'vitest'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import { Hono } from 'hono'
 import type { Database } from 'bun:sqlite'
 import { createInternalRoutes } from '../../src/routes/internal'
@@ -85,7 +87,7 @@ describe('internal-opencode-workspaces routes', () => {
       forwardRaw: vi.fn(),
     } as unknown as OpenCodeClient
     app = new Hono()
-    app.route('/api/internal', createInternalRoutes(mockDb, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(mockDb, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
     token = 'test-internal-token'
   })
 
diff --git a/backend/test/routes/internal-repos.test.ts b/backend/test/routes/internal-repos.test.ts
index 4dc3ec0c9..6b518a8a2 100644
--- a/backend/test/routes/internal-repos.test.ts
+++ b/backend/test/routes/internal-repos.test.ts
@@ -2,6 +2,8 @@ import { describe, it, expect, beforeEach } from 'vitest'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import { Hono } from 'hono'
 import { Database } from 'bun:sqlite'
 import { createInternalRoutes } from '../../src/routes/internal'
@@ -33,7 +35,7 @@ describe('internal-repos routes', () => {
     notificationService = new NotificationService(db)
     settingsService = new SettingsService(db)
     app = new Hono()
-    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
     token = getOrCreateInternalToken(db)
   })
 
diff --git a/backend/test/routes/internal-sandbox.test.ts b/backend/test/routes/internal-sandbox.test.ts
index b30f8fe83..4a1d62b30 100644
--- a/backend/test/routes/internal-sandbox.test.ts
+++ b/backend/test/routes/internal-sandbox.test.ts
@@ -2,6 +2,8 @@ import { afterEach, beforeEach, describe, expect, it, mock, vi } from 'bun:test'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import { Hono } from 'hono'
 import { Database } from 'bun:sqlite'
 import { mkdirSync, rmSync } from 'node:fs'
@@ -96,7 +98,7 @@ describe('internal sandbox routes', () => {
     const notificationService = new NotificationService(db)
     settingsService = new SettingsService(db)
     app = new Hono()
-    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
     token = getOrCreateInternalToken(db)
     repoDir = path.join(getReposPath(), 'sandbox-route-test')
     mkdirSync(repoDir, { recursive: true })
diff --git a/backend/test/routes/internal-schedules.test.ts b/backend/test/routes/internal-schedules.test.ts
index dc42d4994..d0f41635e 100644
--- a/backend/test/routes/internal-schedules.test.ts
+++ b/backend/test/routes/internal-schedules.test.ts
@@ -2,6 +2,8 @@ import { describe, it, expect, beforeEach } from 'vitest'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import { Hono } from 'hono'
 import { Database } from 'bun:sqlite'
 import { createInternalRoutes } from '../../src/routes/internal'
@@ -31,7 +33,7 @@ describe('internal-schedules routes', () => {
     notificationService = new NotificationService(db)
     settingsService = new SettingsService(db)
     app = new Hono()
-    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
     token = getOrCreateInternalToken(db)
   })
 
diff --git a/backend/test/routes/internal-session-goals.test.ts b/backend/test/routes/internal-session-goals.test.ts
new file mode 100644
index 000000000..e7ddc6eed
--- /dev/null
+++ b/backend/test/routes/internal-session-goals.test.ts
@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
+import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
+import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
+import { Hono } from 'hono'
+import { Database } from 'bun:sqlite'
+import { createInternalRoutes } from '../../src/routes/internal'
+import type { ScheduleService } from '../../src/services/schedules'
+import type { NotificationService } from '../../src/services/notification'
+import type { SettingsService } from '../../src/services/settings'
+import type { OpenCodeClient } from '../../src/services/opencode/client'
+import { allMigrations } from '../../src/db/migrations'
+import { getOrCreateInternalToken } from '../../src/services/internal-token'
+import { migrate } from '../../src/db/migration-runner'
+
+function createSessionGoalStub() {
+  return {
+    getLatest: vi.fn(),
+    start: vi.fn(),
+    pause: vi.fn(),
+    resume: vi.fn(),
+    cancel: vi.fn(),
+  }
+}
+
+describe('internal-session-goals routes', () => {
+  let db: Database
+  let sessionGoals: ReturnType<typeof createSessionGoalStub>
+  let app: Hono
+  let token: string
+
+  beforeEach(() => {
+    db = new Database(':memory:')
+    migrate(db, allMigrations)
+    sessionGoals = createSessionGoalStub()
+    app = new Hono()
+    app.route(
+      '/api/internal',
+      createInternalRoutes(
+        db,
+        {} as ScheduleService,
+        {} as NotificationService,
+        {} as SettingsService,
+        {} as OpenCodeClient,
+        {} as SessionPermissionModeService,
+        {} as unknown as RepoWorkspaceService,
+        {} as unknown as GitAuthService,
+        sessionGoals as unknown as SessionGoalService,
+        {} as unknown as MultiRunService,
+      ),
+    )
+    token = getOrCreateInternalToken(db)
+  })
+
+  it('GET /api/internal/session-goals returns 401 without bearer token', async () => {
+    const res = await app.request('/api/internal/session-goals?sessionId=ses_1')
+    expect(res.status).toBe(401)
+  })
+
+  it('GET /api/internal/session-goals returns the latest goal with a bearer token', async () => {
+    sessionGoals.getLatest.mockReturnValue(null)
+
+    const res = await app.request('/api/internal/session-goals?sessionId=ses_1', {
+      headers: { authorization: `Bearer ${token}` },
+    })
+
+    expect(res.status).toBe(200)
+    await expect(res.json()).resolves.toEqual({ goal: null })
+    expect(sessionGoals.getLatest).toHaveBeenCalledWith('ses_1')
+  })
+
+  it('POST /api/internal/session-goals starts a goal', async () => {
+    sessionGoals.start.mockResolvedValue({ id: 1, status: 'active' })
+    const body = { sessionId: 'ses_1', directory: '/abs/repo', objective: 'Ship it' }
+
+    const res = await app.request('/api/internal/session-goals', {
+      method: 'POST',
+      headers: { authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+
+    expect(res.status).toBe(201)
+    await expect(res.json()).resolves.toEqual({ goal: { id: 1, status: 'active' } })
+    expect(sessionGoals.start).toHaveBeenCalledWith(body)
+  })
+
+  it('POST /api/internal/session-goals/7/pause pauses the goal', async () => {
+    sessionGoals.pause.mockReturnValue({ id: 7, status: 'paused' })
+
+    const res = await app.request('/api/internal/session-goals/7/pause', {
+      method: 'POST',
+      headers: { authorization: `Bearer ${token}` },
+    })
+
+    expect(res.status).toBe(200)
+    await expect(res.json()).resolves.toEqual({ goal: { id: 7, status: 'paused' } })
+    expect(sessionGoals.pause).toHaveBeenCalledWith(7)
+  })
+})
diff --git a/backend/test/routes/internal-sessions.test.ts b/backend/test/routes/internal-sessions.test.ts
index 374912716..f4e412151 100644
--- a/backend/test/routes/internal-sessions.test.ts
+++ b/backend/test/routes/internal-sessions.test.ts
@@ -9,6 +9,8 @@ import type { OpenCodeClient } from '../../src/services/opencode/client'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import type { Repo } from '../../src/types/repo'
 
 const mockDb = {
@@ -158,7 +160,7 @@ describe('internal-sessions routes', () => {
     app = new Hono()
     app.route(
       '/api/internal',
-      createInternalRoutes(mockDb, scheduleService, notificationService, settingsService, openCodeClient, permissionModes, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService),
+      createInternalRoutes(mockDb, scheduleService, notificationService, settingsService, openCodeClient, permissionModes, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService),
     )
     token = 'test-internal-token'
   })
diff --git a/backend/test/routes/internal-settings.test.ts b/backend/test/routes/internal-settings.test.ts
index 8316b0541..4110bbfc0 100644
--- a/backend/test/routes/internal-settings.test.ts
+++ b/backend/test/routes/internal-settings.test.ts
@@ -2,6 +2,8 @@ import { describe, it, expect, beforeEach } from 'bun:test'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import { Hono } from 'hono'
 import { Database } from 'bun:sqlite'
 import { createInternalRoutes } from '../../src/routes/internal'
@@ -32,7 +34,7 @@ describe('internal/settings routes', () => {
     notificationService = new NotificationService(db)
     settingsService = new SettingsService(db)
     app = new Hono()
-    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, openCodeClient, {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
     token = getOrCreateInternalToken(db)
   })
 
diff --git a/backend/test/services/assistant-mode.test.ts b/backend/test/services/assistant-mode.test.ts
index cd58e27f5..eae66156c 100644
--- a/backend/test/services/assistant-mode.test.ts
+++ b/backend/test/services/assistant-mode.test.ts
@@ -2,6 +2,8 @@ import { describe, expect, it, beforeEach, afterEach } from 'bun:test'
 import type { SessionPermissionModeService } from '../../src/services/session-permission-modes'
 import type { RepoWorkspaceService } from '../../src/services/repo-workspace'
 import type { GitAuthService } from '../../src/services/git-auth'
+import type { SessionGoalService } from '../../src/services/session-goals'
+import type { MultiRunService } from '../../src/services/multi-runs'
 import path from 'path'
 import { access, readFile, writeFile } from 'fs/promises'
 import { Hono } from 'hono'
@@ -688,7 +690,7 @@ describe('assistant-mode end-to-end', () => {
     const notificationService = new NotificationService(db)
     const settingsService = new SettingsService(db)
     const app = new Hono()
-    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, createOpenCodeClient(), {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService))
+    app.route('/api/internal', createInternalRoutes(db, scheduleService, notificationService, settingsService, createOpenCodeClient(), {} as SessionPermissionModeService, {} as unknown as RepoWorkspaceService, {} as unknown as GitAuthService, {} as unknown as SessionGoalService, {} as unknown as MultiRunService))
 
     const unauth = await app.request('/api/internal/schedules/all')
     expect(unauth.status).toBe(401)
diff --git a/backend/test/services/notification-format.test.ts b/backend/test/services/notification-format.test.ts
index c587fb61d..c83e30f7e 100644
--- a/backend/test/services/notification-format.test.ts
+++ b/backend/test/services/notification-format.test.ts
@@ -5,6 +5,8 @@ import {
   getFormText,
   getGoalOutcomeTitle,
   getGoalStopReasonLabel,
+  getGoalTurnLabel,
+  getGoalTokenLabel,
 } from '@opencode-manager/shared/notifications'
 import { buildEventNotificationPayload, buildNotificationUrl } from '../../src/services/notification'
 import { ASSISTANT_REPO_ID } from '@opencode-manager/shared/utils'
@@ -35,6 +37,20 @@ describe('goal notification labels', () => {
   })
 })
 
+describe('goal progress labels', () => {
+  it('formats the turn counter', () => {
+    expect(getGoalTurnLabel({ continuationCount: 2, maxContinuations: 20 })).toBe('Turn 2/20')
+  })
+
+  it('formats the token usage with locale separators', () => {
+    expect(getGoalTokenLabel({ tokensUsed: 250, tokenBudget: 1000 })).toBe('250/1,000 tokens')
+  })
+
+  it('returns null when there is no token budget', () => {
+    expect(getGoalTokenLabel({ tokensUsed: 250, tokenBudget: null })).toBeNull()
+  })
+})
+
 describe('getPermissionLabel', () => {
   it('maps known V2 permission actions to friendly labels', () => {
     expect(getPermissionLabel('shell')).toBe('Run Command')
diff --git a/backend/test/services/opencode-manager-tool-plugin.test.ts b/backend/test/services/opencode-manager-tool-plugin.test.ts
index 028fdbb29..63e446ffe 100644
--- a/backend/test/services/opencode-manager-tool-plugin.test.ts
+++ b/backend/test/services/opencode-manager-tool-plugin.test.ts
@@ -289,6 +289,14 @@ describe('ocm-manager plugin', () => {
       ['DELETE', '/settings'],
       ['PUT', '/opencode-config'],
       ['DELETE', '/sessions/abc'],
+      ['GET', '/session-goals'],
+      ['POST', '/session-goals'],
+      ['POST', '/session-goals/1/pause'],
+      ['POST', '/session-goals/1/cancel'],
+      ['GET', '/multi-runs'],
+      ['POST', '/multi-runs'],
+      ['POST', '/multi-runs/1/fusions'],
+      ['POST', '/multi-runs/1/entries/2/discard'],
     ] as const
 
     for (const [method, path] of deniedRoutes) {
diff --git a/frontend/src/components/session/SessionGoalBar.tsx b/frontend/src/components/session/SessionGoalBar.tsx
index 44dd797be..769c6012d 100644
--- a/frontend/src/components/session/SessionGoalBar.tsx
+++ b/frontend/src/components/session/SessionGoalBar.tsx
@@ -8,7 +8,7 @@ import {
   useResumeSessionGoal,
   useSessionGoal,
 } from '@/hooks/useSessionGoals'
-import { getGoalOutcomeTitle, getGoalStopReasonLabel } from '@opencode-manager/shared/notifications'
+import { getGoalOutcomeTitle, getGoalStopReasonLabel, getGoalTokenLabel, getGoalTurnLabel } from '@opencode-manager/shared/notifications'
 import type { SessionGoalStatus } from '@opencode-manager/shared/schemas'
 
 const STATUS_CHIP_CLASSES: Record<SessionGoalStatus, string> = {
@@ -38,6 +38,7 @@ export function SessionGoalBar({ sessionID }: { sessionID: string }) {
 
   const terminal = isTerminal(goal.status)
   const reason = goal.stopReason ? getGoalStopReasonLabel(goal.stopReason) : goal.lastReason
+  const tokenLabel = getGoalTokenLabel(goal)
 
   return (
     <div className="mb-1 flex flex-col gap-1 rounded-lg border border-border bg-card px-2 py-1.5 text-xs">
@@ -52,13 +53,13 @@ export function SessionGoalBar({ sessionID }: { sessionID: string }) {
 
         {!terminal && (
           <span className="text-muted-foreground">
-            Turn {goal.continuationCount}/{goal.maxContinuations}
+            {getGoalTurnLabel(goal)}
           </span>
         )}
 
-        {!terminal && goal.tokenBudget !== null && (
+        {!terminal && tokenLabel !== null && (
           <span className="text-muted-foreground">
-            {goal.tokensUsed.toLocaleString()}/{goal.tokenBudget.toLocaleString()} tokens
+            {tokenLabel}
           </span>
         )}
 
diff --git a/ocm-cli/README.md b/ocm-cli/README.md
index 842144cfd..ab8c567fa 100644
--- a/ocm-cli/README.md
+++ b/ocm-cli/README.md
@@ -144,6 +144,39 @@ on the Manager immediately. Use it from inside an OpenCode session after
 `ocm login` and after the repo already exists on the Manager
 (`ocm push --create` if needed).
 
+`/ocm` switches this TUI to another server, the same way the `ocm` CLI picks
+one. In a local TUI it finds the Manager repo that matches the current
+directory (by git origin) and asks to attach to it; when no repo or several
+repos match, it shows a picker of the Manager's ready repos. In a TUI that is
+already attached, the picker offers the other Manager repos and **Local
+opencode**. Switching exits the TUI and reattaches; the current session stays
+where it is (use `/ocm-move` to bring a local session along).
+
+The plugin also registers two Manager-backed commands, both of which need an
+attached Manager repo through `ocm`:
+
+- `/goal [objective]` starts a Manager-driven goal on the current top-level
+  session and sends the objective as the next message. With no objective, a
+  dialog asks for it, plus optional max turns and token budget (blank uses the
+  Manager defaults). Scheduled runs and subagent sessions are rejected by the
+  Manager. While a goal is open, a status line above the composer shows its
+  turn and token usage, and a toast reports the outcome. Running `/goal` while
+  a goal is open shows its live status with `p` to pause or resume and `x`
+  (twice) to cancel.
+- `/multirun [prompt]` opens a launch dialog: prompt, name, a filterable model
+  checklist (up to 5), isolated worktrees or the shared repo directory, and an
+  optional base ref. `ctrl+s` launches, and the started sessions open in tabs.
+  With no prompt, `/multirun` opens the runs browser for the attached repo:
+  pick a run, open entry or fusion sessions, discard entries (`d` twice), select
+  results with `space`, and press `f` to fuse them with a synthesis model. On
+  the run list, `f` fuses every started result of the highlighted run. A fusion
+  always runs in a new worktree.
+
+Both commands need an OpenCode Manager release that exposes
+`/api/internal/session-goals` and `/api/internal/multi-runs`. An older Manager
+answers these requests with `404 Not Found`, and the TUI reports that the
+Manager must be upgraded.
+
 Enable it in `~/.config/opencode/cli.json`:
 
 ```jsonc
diff --git a/ocm-cli/bin/ocm.ts b/ocm-cli/bin/ocm.ts
index 140af6896..ca384e5f6 100644
--- a/ocm-cli/bin/ocm.ts
+++ b/ocm-cli/bin/ocm.ts
@@ -14,6 +14,7 @@ import { resolveTarget, formatRepoIdentities, parseRepoIdPositional, restrictMat
 import { buildAttachInvocation } from '../src/warp.js'
 import { type ManagerRepo, fetchRepos, toRemoteRepoSummaries } from '../src/manager-repos.js'
 import { OCM_VERSION as VERSION, warmRepoProxy } from '../src/repo-proxy.js'
+import { normalizeManagerUrl } from '../src/manager-auth.js'
 
 const USAGE = `ocm v${VERSION} - OpenCode Manager workspace launcher
 
@@ -151,7 +152,7 @@ function findRepo(repos: ManagerRepo[], needle: string | number): ManagerRepo |
 export async function cmdLogin(args: string[]): Promise<void> {
   const url = args[0]
   if (!url) die('usage: ocm login <url> [token]')
-  const normalisedUrl = url.replace(/\/+$/, '')
+  const normalisedUrl = normalizeManagerUrl(url)
 
   let token = args[1]
   if (!token) {
diff --git a/ocm-cli/src/goal-store.ts b/ocm-cli/src/goal-store.ts
new file mode 100644
index 000000000..9e4e131d5
--- /dev/null
+++ b/ocm-cli/src/goal-store.ts
@@ -0,0 +1,113 @@
+import type { SessionGoal } from '@opencode-manager/shared/schemas'
+
+export const GOAL_POLL_INTERVAL_MS = 3000
+
+export type GoalStoreDeps = {
+  load: (sessionID: string) => Promise<SessionGoal | null>
+  onOutcome: (goal: SessionGoal) => void
+  pollIntervalMs?: number
+}
+
+export type GoalStore = {
+  watch(sessionID: string, listener: (goal: SessionGoal | null) => void): () => void
+  set(goal: SessionGoal): void
+  refresh(sessionID: string): Promise<void>
+}
+
+interface GoalEntry {
+  readonly sessionID: string
+  goal: SessionGoal | null
+  listeners: Set<(goal: SessionGoal | null) => void>
+  timer: ReturnType<typeof setInterval> | null
+}
+
+export function isOpenGoal(goal: SessionGoal | null | undefined): goal is SessionGoal {
+  return !!goal && (goal.status === 'active' || goal.status === 'paused')
+}
+
+function isTerminalGoal(goal: SessionGoal): boolean {
+  return goal.status === 'completed' || goal.status === 'blocked' || goal.status === 'stopped'
+}
+
+export function createGoalStore(deps: GoalStoreDeps): GoalStore {
+  const pollIntervalMs = deps.pollIntervalMs ?? GOAL_POLL_INTERVAL_MS
+  const entries = new Map<string, GoalEntry>()
+
+  function entryFor(sessionID: string): GoalEntry {
+    let entry = entries.get(sessionID)
+    if (!entry) {
+      entry = { sessionID, goal: null, listeners: new Set(), timer: null }
+      entries.set(sessionID, entry)
+    }
+    return entry
+  }
+
+  function stopPolling(entry: GoalEntry): void {
+    if (entry.timer !== null) {
+      clearInterval(entry.timer)
+      entry.timer = null
+    }
+  }
+
+  function isLive(entry: GoalEntry): boolean {
+    return entry.listeners.size > 0 && entries.get(entry.sessionID) === entry
+  }
+
+  function startPolling(entry: GoalEntry): void {
+    stopPolling(entry)
+    entry.timer = setInterval(() => {
+      void loadInto(entry)
+    }, pollIntervalMs)
+  }
+
+  function applyGoal(entry: GoalEntry, goal: SessionGoal | null): void {
+    const previous = entry.goal
+    entry.goal = goal
+    for (const listener of entry.listeners) listener(goal)
+    if (entry.listeners.size > 0 && isOpenGoal(previous) && goal !== null && isTerminalGoal(goal)) {
+      deps.onOutcome(goal)
+    }
+    if (goal?.status === 'active' && isLive(entry)) startPolling(entry)
+    else stopPolling(entry)
+  }
+
+  async function loadInto(entry: GoalEntry): Promise<void> {
+    let goal: SessionGoal | null
+    try {
+      goal = await deps.load(entry.sessionID)
+    } catch {
+      if (entry.goal?.status !== 'active' || !isLive(entry)) stopPolling(entry)
+      return
+    }
+    if (entries.get(entry.sessionID) !== entry) {
+      stopPolling(entry)
+      return
+    }
+    applyGoal(entry, goal)
+  }
+
+  return {
+    watch(sessionID, listener) {
+      const entry = entryFor(sessionID)
+      entry.listeners.add(listener)
+      void loadInto(entry)
+      return () => {
+        entry.listeners.delete(listener)
+        if (entry.listeners.size === 0) {
+          stopPolling(entry)
+          entries.delete(sessionID)
+        }
+      }
+    },
+    set(goal) {
+      const entry = entries.get(goal.sessionId)
+      if (!entry) return
+      applyGoal(entry, goal)
+    },
+    refresh(sessionID) {
+      const entry = entries.get(sessionID)
+      if (!entry) return Promise.resolve()
+      return loadInto(entry)
+    },
+  }
+}
diff --git a/ocm-cli/src/manager-api.ts b/ocm-cli/src/manager-api.ts
index 806b46af0..5a54b9e99 100644
--- a/ocm-cli/src/manager-api.ts
+++ b/ocm-cli/src/manager-api.ts
@@ -3,8 +3,15 @@ import { Readable } from 'stream'
 import {
   MirrorTargetEnsureResponseSchema,
   MirrorTargetPlanResponseSchema,
+  MultiRunSchema,
+  SessionGoalSchema,
+  type FuseMultiRunRequest,
+  type LaunchMultiRunRequest,
   type MirrorTargetEnsureResponse,
   type MirrorTargetPlanResponse,
+  type MultiRun,
+  type SessionGoal,
+  type StartSessionGoalRequest,
 } from '@opencode-manager/shared/schemas'
 
 export interface MirrorBeginOpts {
@@ -75,23 +82,30 @@ export class ManagerApiError extends Error {
     public readonly status: number,
     public readonly code: string | null,
     public readonly operation: string,
+    public readonly details: unknown = null,
   ) {
     super(message)
     this.name = 'ManagerApiError'
   }
 }
 
+export function isManagerRouteMissing(error: unknown): boolean {
+  return error instanceof ManagerApiError && error.status === 404 && error.code === null
+}
+
 async function formatErrorResponse(res: Response, operation: string): Promise<ManagerApiError> {
   const text = await res.text().catch(() => '')
   let code: string | null = null
   let detail = text
+  let details: unknown = null
   if (text) {
     try {
-      const parsed = JSON.parse(text) as { error?: unknown; message?: unknown }
+      const parsed = JSON.parse(text) as { error?: unknown; message?: unknown; details?: unknown }
       const errField = typeof parsed.error === 'string' ? parsed.error : null
       const msgField = typeof parsed.message === 'string' ? parsed.message : null
       code = errField
       detail = msgField ?? errField ?? text
+      details = parsed.details ?? null
     } catch {
       /* not JSON, keep raw text */
     }
@@ -99,7 +113,7 @@ async function formatErrorResponse(res: Response, operation: string): Promise<Ma
   const message = detail
     ? `${operation} failed (${res.status}): ${detail}`
     : `${operation} failed (${res.status})`
-  return new ManagerApiError(message, res.status, code, operation)
+  return new ManagerApiError(message, res.status, code, operation, details)
 }
 
 export class ManagerApi {
@@ -255,4 +269,94 @@ export class ManagerApi {
     if (!res.ok) throw await formatErrorResponse(res, 'mirror patch snapshot')
     return (await res.json()) as MirrorPatchSnapshot
   }
+
+  async getLatestSessionGoal(sessionId: string): Promise<SessionGoal | null> {
+    const res = await fetch(`${this.baseUrl}/api/internal/session-goals?sessionId=${encodeURIComponent(sessionId)}`, {
+      headers: this.headers(),
+    })
+
+    if (!res.ok) throw await formatErrorResponse(res, 'read session goal')
+    const body = (await res.json()) as { goal: unknown }
+    return SessionGoalSchema.nullable().parse(body.goal)
+  }
+
+  async startSessionGoal(input: StartSessionGoalRequest): Promise<SessionGoal> {
+    const res = await fetch(`${this.baseUrl}/api/internal/session-goals`, {
+      method: 'POST',
+      headers: { ...this.headers(), 'Content-Type': 'application/json' },
+      body: JSON.stringify(input),
+    })
+
+    if (!res.ok) throw await formatErrorResponse(res, 'start session goal')
+    const body = (await res.json()) as { goal: unknown }
+    return SessionGoalSchema.parse(body.goal)
+  }
+
+  private async runSessionGoalAction(id: number, action: 'pause' | 'resume' | 'cancel'): Promise<SessionGoal> {
+    const res = await fetch(`${this.baseUrl}/api/internal/session-goals/${encodeURIComponent(id)}/${action}`, {
+      method: 'POST',
+      headers: this.headers(),
+    })
+
+    if (!res.ok) throw await formatErrorResponse(res, `${action} session goal`)
+    const body = (await res.json()) as { goal: unknown }
+    return SessionGoalSchema.parse(body.goal)
+  }
+
+  pauseSessionGoal(id: number): Promise<SessionGoal> {
+    return this.runSessionGoalAction(id, 'pause')
+  }
+
+  resumeSessionGoal(id: number): Promise<SessionGoal> {
+    return this.runSessionGoalAction(id, 'resume')
+  }
+
+  cancelSessionGoal(id: number): Promise<SessionGoal> {
+    return this.runSessionGoalAction(id, 'cancel')
+  }
+
+  async listMultiRuns(repoId: number): Promise<MultiRun[]> {
+    const res = await fetch(`${this.baseUrl}/api/internal/multi-runs?repoId=${encodeURIComponent(repoId)}`, {
+      headers: this.headers(),
+    })
+
+    if (!res.ok) throw await formatErrorResponse(res, 'list multi-runs')
+    const body = (await res.json()) as { runs: unknown }
+    return MultiRunSchema.array().parse(body.runs)
+  }
+
+  async launchMultiRun(request: LaunchMultiRunRequest): Promise<MultiRun> {
+    const res = await fetch(`${this.baseUrl}/api/internal/multi-runs`, {
+      method: 'POST',
+      headers: { ...this.headers(), 'Content-Type': 'application/json' },
+      body: JSON.stringify(request),
+    })
+
+    if (!res.ok) throw await formatErrorResponse(res, 'launch multi-run')
+    const body = (await res.json()) as { run: unknown }
+    return MultiRunSchema.parse(body.run)
+  }
+
+  async fuseMultiRun(runId: number, request: FuseMultiRunRequest): Promise<MultiRun> {
+    const res = await fetch(`${this.baseUrl}/api/internal/multi-runs/${encodeURIComponent(runId)}/fusions`, {
+      method: 'POST',
+      headers: { ...this.headers(), 'Content-Type': 'application/json' },
+      body: JSON.stringify(request),
+    })
+
+    if (!res.ok) throw await formatErrorResponse(res, 'fuse multi-run')
+    const body = (await res.json()) as { run: unknown }
+    return MultiRunSchema.parse(body.run)
+  }
+
+  async discardMultiRunEntry(runId: number, entryId: number): Promise<MultiRun> {
+    const res = await fetch(`${this.baseUrl}/api/internal/multi-runs/${encodeURIComponent(runId)}/entries/${encodeURIComponent(entryId)}/discard`, {
+      method: 'POST',
+      headers: this.headers(),
+    })
+
+    if (!res.ok) throw await formatErrorResponse(res, 'discard multi-run entry')
+    const body = (await res.json()) as { run: unknown }
+    return MultiRunSchema.parse(body.run)
+  }
 }
diff --git a/ocm-cli/src/manager-auth.ts b/ocm-cli/src/manager-auth.ts
new file mode 100644
index 000000000..687d77982
--- /dev/null
+++ b/ocm-cli/src/manager-auth.ts
@@ -0,0 +1,37 @@
+import { readState } from './state.js'
+import { getToken } from './internal-token-store.js'
+import { TokenStoreError } from './token-store.js'
+
+export type ManagerAuth =
+  | { ok: true; managerUrl: string; token: string }
+  | { ok: false; message: string }
+
+export type ManagerAuthOk = Extract<ManagerAuth, { ok: true }>
+
+/** Canonical Manager URL form used as the token-store account: trimmed, without trailing slashes. */
+export function normalizeManagerUrl(url: string): string {
+  return url.trim().replace(/\/+$/, '')
+}
+
+export async function resolveManagerAuth(
+  rawManagerUrl: string | undefined = readState()?.managerUrl,
+): Promise<ManagerAuth> {
+  const managerUrl = rawManagerUrl ? normalizeManagerUrl(rawManagerUrl) : ''
+  if (!managerUrl) {
+    return { ok: false, message: 'No manager configured. Run `ocm login <url>` first.' }
+  }
+
+  let token: string | null
+  try {
+    token = await getToken(managerUrl)
+  } catch (err) {
+    const reason = err instanceof TokenStoreError ? err.message : String(err)
+    return { ok: false, message: `Token store unavailable: ${reason}` }
+  }
+
+  if (!token) {
+    return { ok: false, message: `No token stored. Run \`ocm login ${managerUrl}\`.` }
+  }
+
+  return { ok: true, managerUrl, token }
+}
diff --git a/ocm-cli/src/remote-context.ts b/ocm-cli/src/remote-context.ts
index f483f33de..97c61fa64 100644
--- a/ocm-cli/src/remote-context.ts
+++ b/ocm-cli/src/remote-context.ts
@@ -1,15 +1,19 @@
 export const REMOTE_MANAGER_URL_ENV = 'OCM_REMOTE_MANAGER_URL'
 export const REMOTE_REPO_NAME_ENV = 'OCM_REMOTE_REPO_NAME'
+export const REMOTE_REPO_ID_ENV = 'OCM_REMOTE_REPO_ID'
 
 export type RemoteContext = {
+  managerUrl: string
   managerHost: string
   repoName?: string
+  repoId?: number
 }
 
-export function buildRemoteAttachEnv(managerUrl: string, repoName: string): Record<string, string> {
+export function buildRemoteAttachEnv(managerUrl: string, repoName: string, repoId: number): Record<string, string> {
   return {
     [REMOTE_MANAGER_URL_ENV]: managerUrl,
     [REMOTE_REPO_NAME_ENV]: repoName,
+    [REMOTE_REPO_ID_ENV]: String(repoId),
   }
 }
 
@@ -17,14 +21,19 @@ export function readRemoteContext(env: NodeJS.ProcessEnv): RemoteContext | undef
   const urlValue = env[REMOTE_MANAGER_URL_ENV]
   if (!urlValue) return undefined
 
+  const managerUrl = urlValue.trim()
+
   let managerHost: string
   try {
-    managerHost = new URL(urlValue).host
+    managerHost = new URL(managerUrl).host
   } catch {
-    managerHost = urlValue.trim()
+    managerHost = managerUrl
   }
 
   const repoName = env[REMOTE_REPO_NAME_ENV] || undefined
 
-  return { managerHost, repoName }
-}
\ No newline at end of file
+  const repoIdValue = Number(env[REMOTE_REPO_ID_ENV])
+  const repoId = Number.isInteger(repoIdValue) && repoIdValue > 0 ? repoIdValue : undefined
+
+  return { managerUrl, managerHost, repoName, repoId }
+}
diff --git a/ocm-cli/src/tui-dialogs.ts b/ocm-cli/src/tui-dialogs.ts
index 723efced6..6ed62584e 100644
--- a/ocm-cli/src/tui-dialogs.ts
+++ b/ocm-cli/src/tui-dialogs.ts
@@ -1,4 +1,4 @@
-import type { Context } from '@opencode/plugin/tui/context'
+import type { Context, DialogSelectOption } from '@opencode/plugin/tui/context'
 
 export function confirmDialog(context: Context, props: { title: string; message: string }): Promise<boolean> {
   return context.ui.dialog.confirm(props).then((value) => value === true)
@@ -7,7 +7,15 @@ export function confirmDialog(context: Context, props: { title: string; message:
 export function selectDialog<Value>(
   context: Context,
   title: string,
-  options: { title: string; description?: string; value: Value }[],
+  options: readonly DialogSelectOption<Value>[],
 ): Promise<Value | undefined> {
   return context.ui.dialog.select({ title, options })
 }
+
+export function slashArgument(input: string | undefined, name: string): string {
+  const trimmed = (input ?? '').trim()
+  const prefix = `/${name}`
+  if (trimmed === prefix) return ''
+  if (trimmed.startsWith(`${prefix} `)) return trimmed.slice(prefix.length).trim()
+  return trimmed
+}
diff --git a/ocm-cli/src/tui-form.tsx b/ocm-cli/src/tui-form.tsx
new file mode 100644
index 000000000..332cfd053
--- /dev/null
+++ b/ocm-cli/src/tui-form.tsx
@@ -0,0 +1,304 @@
+/** @jsxImportSource @opentui/solid */
+import { TextAttributes, type KeyEvent, type TextareaRenderable } from '@opentui/core'
+import { useKeyboard } from '@opentui/solid'
+import { createEffect, createMemo, createSignal, For, Show, type JSX } from 'solid-js'
+import type { Context } from '@opencode/plugin/tui/context'
+import { filterModelOptions } from './tui-multi-run.js'
+import type { ModelOption } from './tui-multi-run.js'
+
+export type DialogTheme = ReturnType<Context['theme']['surface']>
+
+export type KeyHint = readonly [key: string, label: string]
+
+const PICKER_ROWS = 8
+
+/**
+ * Row colors matching OpenCode's select dialogs: every text in the cursor row uses the
+ * primary-action focused color on the focused background; a chosen row away from the
+ * cursor uses the selected form-field color for its marker and title.
+ */
+export function rowColors(theme: DialogTheme, state: { active: boolean; chosen?: boolean }) {
+  if (state.active) {
+    const text = theme.text.action.primary.focused
+    return { background: theme.background.action.primary.focused, title: text, detail: text, marker: text, bold: true }
+  }
+  return {
+    background: undefined,
+    title: state.chosen ? theme.text.formfield.selected : theme.text.base,
+    detail: theme.text.muted,
+    marker: state.chosen ? theme.text.formfield.selected : theme.text.muted,
+    bold: false,
+  }
+}
+
+/** True for the dialog-wide submit chord. */
+export function isSubmitKey(event: KeyEvent): boolean {
+  return event.ctrl && event.name === 's'
+}
+
+/** Tab / Shift+Tab focus cycling over `count` fields; returns the focused index accessor. */
+export function useFieldFocus(count: () => number, enabled: () => boolean = () => true) {
+  const [index, setIndex] = createSignal(0)
+  createEffect(() => {
+    if (index() >= count()) setIndex(Math.max(0, count() - 1))
+  })
+  useKeyboard((event) => {
+    if (!enabled() || event.name !== 'tab') return
+    event.preventDefault()
+    setIndex((current) => (current + (event.shift ? count() - 1 : 1)) % count())
+  })
+  return [index, setIndex] as const
+}
+
+export function DialogShell(props: {
+  theme: DialogTheme
+  title: string
+  subtitle?: string
+  hints: readonly KeyHint[]
+  error?: string | null
+  busy?: string | null
+  children: JSX.Element
+}) {
+  return (
+    <box paddingLeft={2} paddingRight={2} paddingBottom={1} gap={1}>
+      <box flexDirection="row" justifyContent="space-between" gap={2}>
+        <box flexDirection="row" gap={2} flexShrink={1}>
+          <text attributes={TextAttributes.BOLD} fg={props.theme.text.base} flexShrink={0}>
+            {props.title}
+          </text>
+          <Show when={props.subtitle}>
+            {(subtitle) => (
+              <text fg={props.theme.text.muted} wrapMode="none" truncate>
+                {subtitle()}
+              </text>
+            )}
+          </Show>
+        </box>
+        <text fg={props.theme.text.muted} flexShrink={0}>
+          esc
+        </text>
+      </box>
+      {props.children}
+      <Show when={props.busy}>{(message) => <text fg={props.theme.text.feedback.info.base}>{message()}</text>}</Show>
+      <Show when={props.error}>{(message) => <text fg={props.theme.text.feedback.error.base}>{message()}</text>}</Show>
+      <box flexDirection="row" gap={2} flexWrap="wrap">
+        <For each={props.hints}>
+          {(hint) => (
+            <text fg={props.theme.text.base}>
+              {hint[0]} <span style={{ fg: props.theme.text.muted }}>{hint[1]}</span>
+            </text>
+          )}
+        </For>
+      </box>
+    </box>
+  )
+}
+
+export function FieldLabel(props: { theme: DialogTheme; label: string; focused: boolean; detail?: string }) {
+  return (
+    <box flexDirection="row" gap={2}>
+      <text fg={props.focused ? props.theme.text.formfield.focused : props.theme.text.muted}>{props.label}</text>
+      <Show when={props.detail}>{(detail) => <text fg={props.theme.text.muted}>{detail()}</text>}</Show>
+    </box>
+  )
+}
+
+export function TextField(props: {
+  theme: DialogTheme
+  label: string
+  initialValue: string
+  placeholder?: string
+  focused: boolean
+  onInput: (value: string) => void
+  onSubmit?: () => void
+}) {
+  const initial = props.initialValue
+  return (
+    <box>
+      <FieldLabel theme={props.theme} label={props.label} focused={props.focused} />
+      <input
+        value={initial}
+        focused={props.focused}
+        placeholder={props.placeholder}
+        placeholderColor={props.theme.text.muted}
+        textColor={props.theme.text.formfield.base}
+        focusedTextColor={props.theme.text.formfield.focused}
+        focusedBackgroundColor={props.theme.background.formfield.focused}
+        cursorColor={props.theme.text.formfield.focused}
+        onInput={props.onInput}
+        onSubmit={() => props.onSubmit?.()}
+      />
+    </box>
+  )
+}
+
+export function TextAreaField(props: {
+  theme: DialogTheme
+  label: string
+  initialValue: string
+  placeholder?: string
+  focused: boolean
+  height: number
+  onInput: (value: string) => void
+}) {
+  const initial = props.initialValue
+  let textarea: TextareaRenderable | undefined
+  return (
+    <box>
+      <FieldLabel theme={props.theme} label={props.label} focused={props.focused} />
+      <textarea
+        ref={(value: TextareaRenderable) => (textarea = value)}
+        initialValue={initial}
+        height={props.height}
+        focused={props.focused}
+        placeholder={props.placeholder}
+        placeholderColor={props.theme.text.muted}
+        textColor={props.theme.text.formfield.base}
+        focusedTextColor={props.theme.text.formfield.focused}
+        focusedBackgroundColor={props.theme.background.formfield.focused}
+        cursorColor={props.theme.text.formfield.focused}
+        onContentChange={() => props.onInput(textarea?.plainText ?? '')}
+      />
+    </box>
+  )
+}
+
+/** A two-way choice rendered as radio buttons; ←/→/space switch it while focused. */
+export function ChoiceField<Value>(props: {
+  theme: DialogTheme
+  label: string
+  focused: boolean
+  value: Value
+  options: readonly { title: string; value: Value }[]
+  onChange: (value: Value) => void
+}) {
+  useKeyboard((event) => {
+    if (!props.focused || !['left', 'right', 'space'].includes(event.name)) return
+    event.preventDefault()
+    const index = props.options.findIndex((option) => option.value === props.value)
+    const step = event.name === 'left' ? props.options.length - 1 : 1
+    props.onChange(props.options[(index + step) % props.options.length]!.value)
+  })
+  return (
+    <box>
+      <FieldLabel theme={props.theme} label={props.label} focused={props.focused} />
+      <box flexDirection="row" gap={3}>
+        <For each={props.options}>
+          {(option) => {
+            const active = () => option.value === props.value
+            return (
+              <text fg={active() ? props.theme.text.formfield.selected : props.theme.text.muted}>
+                {active() ? '●' : '○'} {option.title}
+              </text>
+            )
+          }}
+        </For>
+      </box>
+    </box>
+  )
+}
+
+/**
+ * Filterable model list. Typing filters, ↑/↓ move, Enter toggles (multiple) or picks (single).
+ * Selection state is owned by the caller.
+ */
+export function ModelPicker(props: {
+  theme: DialogTheme
+  label: string
+  options: readonly ModelOption[] | undefined
+  selected: readonly string[]
+  multiple: boolean
+  max: number
+  focused: boolean
+  onToggle: (value: string) => void
+}) {
+  const [query, setQuery] = createSignal('')
+  const [cursor, setCursor] = createSignal(0)
+  const filtered = createMemo(() => filterModelOptions(props.options ?? [], query()))
+  const windowStart = createMemo(() => Math.max(0, Math.min(cursor() - Math.floor(PICKER_ROWS / 2), filtered().length - PICKER_ROWS)))
+  const visible = createMemo(() => filtered().slice(windowStart(), windowStart() + PICKER_ROWS))
+
+  createEffect(() => {
+    if (cursor() >= filtered().length) setCursor(Math.max(0, filtered().length - 1))
+  })
+
+  useKeyboard((event) => {
+    if (!props.focused || (event.name !== 'up' && event.name !== 'down')) return
+    event.preventDefault()
+    const count = filtered().length
+    if (count === 0) return
+    setCursor((current) => (current + (event.name === 'up' ? count - 1 : 1)) % count)
+  })
+
+  const toggleCurrent = () => {
+    const option = filtered()[cursor()]
+    if (!option) return
+    if (props.multiple && !props.selected.includes(option.value) && props.selected.length >= props.max) return
+    props.onToggle(option.value)
+  }
+
+  const marker = (value: string) => {
+    const chosen = props.selected.includes(value)
+    if (props.multiple) return chosen ? '[x]' : '[ ]'
+    return chosen ? '●' : '○'
+  }
+
+  return (
+    <box>
+      <FieldLabel
+        theme={props.theme}
+        label={props.label}
+        focused={props.focused}
+        detail={props.multiple ? `${props.selected.length}/${props.max} selected` : props.selected[0]}
+      />
+      <input
+        focused={props.focused}
+        placeholder="Type to filter models"
+        placeholderColor={props.theme.text.muted}
+        textColor={props.theme.text.formfield.base}
+        focusedTextColor={props.theme.text.formfield.focused}
+        focusedBackgroundColor={props.theme.background.formfield.focused}
+        cursorColor={props.theme.text.formfield.focused}
+        onInput={(value) => {
+          setQuery(value)
+          setCursor(0)
+        }}
+        onSubmit={toggleCurrent}
+      />
+      <Show
+        when={props.options}
+        fallback={<text fg={props.theme.text.muted}>Loading models…</text>}
+      >
+        <Show when={filtered().length > 0} fallback={<text fg={props.theme.text.muted}>No matching models</text>}>
+          <For each={visible()}>
+            {(option, index) => {
+              const colors = () =>
+                rowColors(props.theme, {
+                  active: props.focused && windowStart() + index() === cursor(),
+                  chosen: props.selected.includes(option.value),
+                })
+              return (
+                <box flexDirection="row" gap={1} backgroundColor={colors().background}>
+                  <text fg={colors().marker} flexShrink={0}>
+                    {marker(option.value)}
+                  </text>
+                  <text fg={colors().title} attributes={colors().bold ? TextAttributes.BOLD : undefined} flexShrink={0}>
+                    {option.title}
+                  </text>
+                  <text fg={colors().detail} wrapMode="none" truncate>
+                    {option.description}
+                  </text>
+                </box>
+              )
+            }}
+          </For>
+          <Show when={filtered().length > PICKER_ROWS}>
+            <text fg={props.theme.text.muted}>
+              {cursor() + 1}/{filtered().length}
+            </text>
+          </Show>
+        </Show>
+      </Show>
+    </box>
+  )
+}
diff --git a/ocm-cli/src/tui-goal-dialog.tsx b/ocm-cli/src/tui-goal-dialog.tsx
new file mode 100644
index 000000000..7fefbe50e
--- /dev/null
+++ b/ocm-cli/src/tui-goal-dialog.tsx
@@ -0,0 +1,189 @@
+/** @jsxImportSource @opentui/solid */
+import { TextAttributes } from '@opentui/core'
+import { useKeyboard } from '@opentui/solid'
+import { createEffect, createSignal, on, onCleanup, Show } from 'solid-js'
+import type { Context } from '@opencode/plugin/tui/context'
+import type { SessionGoal } from '@opencode-manager/shared/schemas'
+import { getGoalOutcomeTitle, getGoalTokenLabel, getGoalTurnLabel } from '@opencode-manager/shared/notifications'
+import { isOpenGoal } from './goal-store.js'
+import { goalReason } from './tui-goal.js'
+import type { GoalDialogProps } from './tui-goal.js'
+import { DialogShell, TextAreaField, TextField, isSubmitKey, useFieldFocus } from './tui-form.js'
+import type { DialogTheme } from './tui-form.js'
+
+const FORM_FIELDS = 3
+
+export function showGoalDialog(context: Context, props: GoalDialogProps): void {
+  context.ui.dialog.show(() => <GoalDialog context={context} {...props} />)
+  context.ui.dialog.set({ size: 'large' })
+}
+
+function GoalDialog(props: GoalDialogProps & { context: Context }) {
+  const theme: DialogTheme = props.context.theme.surface('dialog')
+  const [goal, setGoal] = createSignal<SessionGoal | null>(props.initialGoal)
+  const [busy, setBusy] = createSignal<string | null>(null)
+  const [error, setError] = createSignal<string | null>(null)
+  const [confirmCancel, setConfirmCancel] = createSignal(false)
+  const [objective, setObjective] = createSignal(props.initialObjective)
+  const [maxTurns, setMaxTurns] = createSignal('')
+  const [tokenBudget, setTokenBudget] = createSignal('')
+
+  onCleanup(props.store.watch(props.sessionID, (next) => setGoal(next)))
+  createEffect(on([objective, maxTurns, tokenBudget], () => setError(null), { defer: true }))
+
+  const openGoal = () => {
+    const current = goal()
+    return isOpenGoal(current) ? current : null
+  }
+  const [field, setField] = useFieldFocus(() => FORM_FIELDS, () => openGoal() === null)
+
+  const run = async (label: string, operation: () => Promise<string | null>): Promise<string | null | undefined> => {
+    if (busy()) return undefined
+    setBusy(label)
+    setError(null)
+    const failure = await operation()
+    setBusy(null)
+    setError(failure)
+    return failure
+  }
+
+  const start = async () => {
+    const failure = await run('Starting goal…', () =>
+      props.actions.start({ objective: objective(), maxTurns: maxTurns(), tokenBudget: tokenBudget() }),
+    )
+    if (failure === null) props.context.ui.dialog.clear()
+  }
+
+  useKeyboard((event) => {
+    const current = openGoal()
+    if (!current) {
+      if (!isSubmitKey(event)) return
+      event.preventDefault()
+      void start()
+      return
+    }
+    if (event.name === 'p') {
+      event.preventDefault()
+      setConfirmCancel(false)
+      void run(current.status === 'paused' ? 'Resuming goal…' : 'Pausing goal…', () =>
+        current.status === 'paused' ? props.actions.resume(current) : props.actions.pause(current),
+      )
+      return
+    }
+    if (event.name === 'x') {
+      event.preventDefault()
+      if (!confirmCancel()) {
+        setConfirmCancel(true)
+        return
+      }
+      setConfirmCancel(false)
+      void run('Cancelling goal…', () => props.actions.cancel(current))
+    }
+  })
+
+  return (
+    <Show
+      when={openGoal()}
+      fallback={
+        <DialogShell
+          theme={theme}
+          title="Start goal"
+          subtitle="Runs until the Manager's auditor says it is done"
+          busy={busy()}
+          error={error()}
+          hints={[
+            ['tab', 'next field'],
+            ['ctrl+s', 'start goal'],
+          ]}
+        >
+          <Show when={goal()}>{(last) => <LastGoal theme={theme} goal={last()} />}</Show>
+          <TextAreaField
+            theme={theme}
+            label="Objective"
+            initialValue={props.initialObjective}
+            placeholder="What should this session accomplish?"
+            height={4}
+            focused={field() === 0}
+            onInput={setObjective}
+          />
+          <box flexDirection="row" gap={4}>
+            <box flexGrow={1}>
+              <TextField
+                theme={theme}
+                label="Max turns"
+                initialValue=""
+                placeholder="Manager default"
+                focused={field() === 1}
+                onInput={setMaxTurns}
+                onSubmit={() => setField(2)}
+              />
+            </box>
+            <box flexGrow={1}>
+              <TextField
+                theme={theme}
+                label="Token budget"
+                initialValue=""
+                placeholder="Manager default"
+                focused={field() === 2}
+                onInput={setTokenBudget}
+                onSubmit={() => void start()}
+              />
+            </box>
+          </box>
+        </DialogShell>
+      }
+    >
+      {(current) => (
+        <DialogShell
+          theme={theme}
+          title="Session goal"
+          busy={busy()}
+          error={error()}
+          hints={[
+            ['p', current().status === 'paused' ? 'resume' : 'pause'],
+            ['x', 'cancel goal'],
+          ]}
+        >
+          <GoalStatus theme={theme} goal={current()} />
+          <Show when={confirmCancel()}>
+            <text fg={theme.text.feedback.warning.base}>Press x again to cancel the goal. This cannot be undone.</text>
+          </Show>
+        </DialogShell>
+      )}
+    </Show>
+  )
+}
+
+function GoalStatus(props: { theme: DialogTheme; goal: SessionGoal }) {
+  const tone = () => (props.goal.status === 'active' ? props.theme.text.feedback.info.base : props.theme.text.feedback.warning.base)
+  return (
+    <box gap={1}>
+      <box flexDirection="row" gap={2} flexWrap="wrap">
+        <text fg={tone()} attributes={TextAttributes.BOLD}>
+          {getGoalOutcomeTitle(props.goal.status)}
+        </text>
+        <text fg={props.theme.text.muted}>{getGoalTurnLabel(props.goal)}</text>
+        <Show when={getGoalTokenLabel(props.goal)}>{(tokens) => <text fg={props.theme.text.muted}>{tokens()}</text>}</Show>
+        <text fg={props.theme.text.muted}>{props.goal.turnState === 'running' ? 'working' : 'waiting'}</text>
+      </box>
+      <text fg={props.theme.text.base}>{props.goal.objective}</text>
+      <Show when={goalReason(props.goal)}>
+        {(reason) => (
+          <text fg={props.theme.text.muted}>
+            {props.goal.lastVerdict ? `Last verdict: ${props.goal.lastVerdict} · ` : ''}
+            {reason()}
+          </text>
+        )}
+      </Show>
+    </box>
+  )
+}
+
+function LastGoal(props: { theme: DialogTheme; goal: SessionGoal }) {
+  return (
+    <text fg={props.theme.text.muted} wrapMode="none" truncate>
+      Last goal: {getGoalOutcomeTitle(props.goal.status)}
+      {goalReason(props.goal) ? ` · ${goalReason(props.goal)}` : ''} · {props.goal.objective}
+    </text>
+  )
+}
diff --git a/ocm-cli/src/tui-goal.ts b/ocm-cli/src/tui-goal.ts
new file mode 100644
index 000000000..b1cd20d96
--- /dev/null
+++ b/ocm-cli/src/tui-goal.ts
@@ -0,0 +1,204 @@
+import type { Context, ToastOptions } from '@opencode/plugin/tui/context'
+import {
+  GOAL_MAX_CONTINUATIONS_MAX,
+  GOAL_MAX_CONTINUATIONS_MIN,
+  StartSessionGoalRequestSchema,
+  type SessionGoal,
+  type StartSessionGoalRequest,
+} from '@opencode-manager/shared/schemas'
+import {
+  getGoalOutcomeTitle,
+  getGoalStopReasonLabel,
+  getGoalTokenLabel,
+  getGoalTurnLabel,
+} from '@opencode-manager/shared/notifications'
+import { ManagerApi, isManagerRouteMissing } from './manager-api.js'
+import { resolveManagerAuth } from './manager-auth.js'
+import type { ManagerAuthOk } from './manager-auth.js'
+import { slashArgument } from './tui-dialogs.js'
+import { isOpenGoal } from './goal-store.js'
+import type { GoalStore } from './goal-store.js'
+import type { RemoteContext } from './remote-context.js'
+
+export const GOALS_ATTACH_REQUIRED =
+  'Goals run on OpenCode Manager. Attach with `ocm` (or move this session with /ocm-move) first.'
+export const GOALS_ROUTE_MISSING = 'This OpenCode Manager does not expose goals to ocm; upgrade the Manager.'
+
+export type GoalFormInput = {
+  objective: string
+  maxTurns: string
+  tokenBudget: string
+}
+
+export type GoalFormResult = { ok: true; request: StartSessionGoalRequest } | { ok: false; error: string }
+
+/** Goal operations the goal dialog calls. Each resolves to an error message, or null on success. */
+export type GoalActions = {
+  start(form: GoalFormInput): Promise<string | null>
+  pause(goal: SessionGoal): Promise<string | null>
+  resume(goal: SessionGoal): Promise<string | null>
+  cancel(goal: SessionGoal): Promise<string | null>
+}
+
+export type GoalDialogProps = {
+  sessionID: string
+  store: GoalStore
+  initialGoal: SessionGoal | null
+  initialObjective: string
+  actions: GoalActions
+}
+
+export type GoalCommandDeps = {
+  remote: RemoteContext | undefined
+  store: GoalStore | undefined
+  showDialog: (props: GoalDialogProps) => void
+  createApi?: (auth: ManagerAuthOk) => ManagerApi
+}
+
+export function formatGoalStatus(goal: SessionGoal): string {
+  return [getGoalOutcomeTitle(goal.status), getGoalTurnLabel(goal), getGoalTokenLabel(goal), goal.objective]
+    .filter((part): part is string => part !== null)
+    .join(' · ')
+}
+
+export function goalOutcomeToast(goal: SessionGoal): ToastOptions {
+  const variant = goal.status === 'completed' ? 'success' : goal.status === 'blocked' ? 'error' : 'warning'
+  return {
+    variant,
+    title: getGoalOutcomeTitle(goal.status),
+    message: goalReason(goal) ?? goal.objective,
+  }
+}
+
+/** The stop-reason label, else the auditor's last reason, else null. */
+export function goalReason(goal: SessionGoal): string | null {
+  return goal.stopReason ? getGoalStopReasonLabel(goal.stopReason) : goal.lastReason
+}
+
+/** Validates the goal dialog fields into a start request; blank limits fall back to the Manager defaults. */
+export function parseGoalForm(form: GoalFormInput, sessionId: string, directory: string): GoalFormResult {
+  const objective = form.objective.trim()
+  if (!objective) return { ok: false, error: 'Describe what this session should accomplish.' }
+
+  const maxContinuations = parseOptionalInteger(form.maxTurns)
+  if (
+    maxContinuations === null ||
+    (maxContinuations !== undefined &&
+      (maxContinuations < GOAL_MAX_CONTINUATIONS_MIN || maxContinuations > GOAL_MAX_CONTINUATIONS_MAX))
+  ) {
+    return { ok: false, error: `Max turns must be a whole number from ${GOAL_MAX_CONTINUATIONS_MIN} to ${GOAL_MAX_CONTINUATIONS_MAX}.` }
+  }
+
+  const tokenBudget = parseOptionalInteger(form.tokenBudget)
+  if (tokenBudget === null || (tokenBudget !== undefined && tokenBudget <= 0)) {
+    return { ok: false, error: 'Token budget must be a positive whole number.' }
+  }
+
+  const parsed = StartSessionGoalRequestSchema.safeParse({
+    sessionId,
+    directory,
+    objective,
+    ...(maxContinuations !== undefined ? { maxContinuations } : {}),
+    ...(tokenBudget !== undefined ? { tokenBudget } : {}),
+  })
+  if (!parsed.success) return { ok: false, error: parsed.error.issues[0]?.message ?? 'Invalid goal.' }
+  return { ok: true, request: parsed.data }
+}
+
+export function describeGoalError(error: unknown): string {
+  if (isManagerRouteMissing(error)) return GOALS_ROUTE_MISSING
+  return error instanceof Error ? error.message : String(error)
+}
+
+export async function runGoalCommand(context: Context, deps: GoalCommandDeps, input?: string): Promise<void> {
+  try {
+    if (!deps.remote || !deps.store) {
+      context.ui.toast.show({ variant: 'error', message: GOALS_ATTACH_REQUIRED })
+      return
+    }
+
+    const route = context.ui.router.current()
+    if (route.type !== 'session') {
+      context.ui.toast.show({ variant: 'error', message: 'Not in a session' })
+      return
+    }
+    const sessionID = route.sessionID
+    const directory = context.data.session.get(sessionID)?.location.directory
+    if (!directory) {
+      context.ui.toast.show({ variant: 'error', message: 'Session has no directory' })
+      return
+    }
+
+    const auth = await resolveManagerAuth(deps.remote.managerUrl)
+    if (!auth.ok) {
+      context.ui.toast.show({ variant: 'error', message: auth.message })
+      return
+    }
+    const api = deps.createApi ? deps.createApi(auth) : new ManagerApi(auth.managerUrl, auth.token)
+    const store = deps.store
+    const actions = createGoalActions(context, api, store, sessionID, directory)
+
+    const objective = slashArgument(input, 'goal')
+    const existing = await api.getLatestSessionGoal(sessionID)
+    if (objective && !isOpenGoal(existing)) {
+      const error = await actions.start({ objective, maxTurns: '', tokenBudget: '' })
+      if (error) context.ui.toast.show({ variant: 'error', message: error })
+      return
+    }
+
+    deps.showDialog({ sessionID, store, initialGoal: existing, initialObjective: objective, actions })
+  } catch (error) {
+    context.ui.toast.show({ variant: 'error', message: describeGoalError(error) })
+  }
+}
+
+function createGoalActions(context: Context, api: ManagerApi, store: GoalStore, sessionID: string, directory: string): GoalActions {
+  const run = async (operation: () => Promise<SessionGoal>): Promise<string | null> => {
+    try {
+      store.set(await operation())
+      return null
+    } catch (error) {
+      return describeGoalError(error)
+    }
+  }
+
+  return {
+    async start(form) {
+      const parsed = parseGoalForm(form, sessionID, directory)
+      if (!parsed.ok) return parsed.error
+      return startGoal(context, api, store, parsed.request)
+    },
+    pause: (goal) => run(() => api.pauseSessionGoal(goal.id)),
+    resume: (goal) => run(() => api.resumeSessionGoal(goal.id)),
+    cancel: (goal) => run(() => api.cancelSessionGoal(goal.id)),
+  }
+}
+
+async function startGoal(context: Context, api: ManagerApi, store: GoalStore, request: StartSessionGoalRequest): Promise<string | null> {
+  let goal: SessionGoal
+  try {
+    goal = await api.startSessionGoal(request)
+  } catch (error) {
+    return describeGoalError(error)
+  }
+  store.set(goal)
+
+  try {
+    await context.client.session.prompt({
+      sessionID: request.sessionId,
+      text: request.objective,
+      delivery: context.data.session.status(request.sessionId) === 'running' ? 'queue' : undefined,
+    })
+    return null
+  } catch (error) {
+    const cancelled = await api.cancelSessionGoal(goal.id).catch(() => undefined)
+    if (cancelled) store.set(cancelled)
+    return `The goal was cancelled because the objective could not be sent: ${error instanceof Error ? error.message : String(error)}`
+  }
+}
+
+function parseOptionalInteger(value: string): number | undefined | null {
+  const trimmed = value.trim()
+  if (!trimmed) return undefined
+  return /^\d+$/.test(trimmed) ? Number(trimmed) : null
+}
diff --git a/ocm-cli/src/tui-multi-run-dialogs.tsx b/ocm-cli/src/tui-multi-run-dialogs.tsx
new file mode 100644
index 000000000..a55ecceb4
--- /dev/null
+++ b/ocm-cli/src/tui-multi-run-dialogs.tsx
@@ -0,0 +1,572 @@
+/** @jsxImportSource @opentui/solid */
+import { TextAttributes } from '@opentui/core'
+import { useKeyboard } from '@opentui/solid'
+import { createEffect, createMemo, createSignal, For, on, onMount, Show } from 'solid-js'
+import type { Context } from '@opencode/plugin/tui/context'
+import {
+  MULTI_RUN_FUSION_MIN_SOURCES,
+  MULTI_RUN_MAX_MODELS,
+  type MultiRun,
+  type MultiRunEntry,
+  type MultiRunFusion,
+} from '@opencode-manager/shared/schemas'
+import {
+  canDiscard,
+  defaultMultiRunName,
+  formatEntryStatus,
+  runSummary,
+  startedEntries,
+  toggleFusionSource,
+} from './tui-multi-run.js'
+import type { ModelOption, MultiRunActions, MultiRunLaunchDialogProps, MultiRunsDialogProps } from './tui-multi-run.js'
+import {
+  ChoiceField,
+  DialogShell,
+  ModelPicker,
+  TextAreaField,
+  TextField,
+  isSubmitKey,
+  rowColors,
+  useFieldFocus,
+} from './tui-form.js'
+import type { DialogTheme } from './tui-form.js'
+
+const ISOLATION_OPTIONS = [
+  { title: 'Isolated worktrees (recommended)', value: true },
+  { title: 'Shared repo directory', value: false },
+] as const
+
+const RUN_LIST_WIDTH = 34
+
+export function showMultiRunLaunchDialog(context: Context, props: MultiRunLaunchDialogProps): void {
+  context.ui.dialog.show(() => <MultiRunLaunchDialog context={context} {...props} />)
+  context.ui.dialog.set({ size: 'large' })
+}
+
+export function showMultiRunsDialog(context: Context, props: MultiRunsDialogProps): void {
+  context.ui.dialog.show(() => <MultiRunsDialog context={context} {...props} />)
+  context.ui.dialog.set({ size: 'xlarge' })
+}
+
+function useModelOptions(actions: MultiRunActions, onError: (message: string) => void) {
+  const [models, setModels] = createSignal<ModelOption[] | undefined>()
+  onMount(async () => {
+    const result = await actions.loadModels()
+    if (result.ok) setModels(result.value)
+    else onError(result.error)
+  })
+  return models
+}
+
+function MultiRunLaunchDialog(props: MultiRunLaunchDialogProps & { context: Context }) {
+  const theme: DialogTheme = props.context.theme.surface('dialog')
+  const [prompt, setPrompt] = createSignal(props.initialPrompt)
+  const [name, setName] = createSignal('')
+  const [selected, setSelected] = createSignal<string[]>([])
+  const [isolate, setIsolate] = createSignal(true)
+  const [baseRef, setBaseRef] = createSignal('')
+  const [busy, setBusy] = createSignal<string | null>(null)
+  const [error, setError] = createSignal<string | null>(null)
+  const models = useModelOptions(props.actions, setError)
+  const [field, setField] = useFieldFocus(() => (isolate() ? 5 : 4))
+  createEffect(on([prompt, name, selected, isolate, baseRef], () => setError(null), { defer: true }))
+
+  const launch = async () => {
+    if (busy()) return
+    setBusy('Launching…')
+    setError(null)
+    const failure = await props.actions.launch({
+      prompt: prompt(),
+      name: name(),
+      models: selected(),
+      isolate: isolate(),
+      baseRef: baseRef(),
+    })
+    setBusy(null)
+    if (failure === null) {
+      props.context.ui.dialog.clear()
+      return
+    }
+    setError(failure)
+  }
+
+  useKeyboard((event) => {
+    if (!isSubmitKey(event)) return
+    event.preventDefault()
+    void launch()
+  })
+
+  const toggleModel = (value: string) =>
+    setSelected((current) => (current.includes(value) ? current.filter((model) => model !== value) : [...current, value]))
+
+  return (
+    <DialogShell
+      theme={theme}
+      title="New multi-run"
+      subtitle={`One prompt, up to ${MULTI_RUN_MAX_MODELS} models`}
+      busy={busy()}
+      error={error()}
+      hints={[
+        ['tab', 'next field'],
+        ['enter', 'toggle model'],
+        ['ctrl+s', 'launch'],
+      ]}
+    >
+      <TextAreaField
+        theme={theme}
+        label="Prompt"
+        initialValue={props.initialPrompt}
+        placeholder="The prompt every model receives"
+        height={5}
+        focused={field() === 0}
+        onInput={setPrompt}
+      />
+      <TextField
+        theme={theme}
+        label="Name"
+        initialValue=""
+        placeholder={defaultMultiRunName(prompt()) || 'Name this group of runs'}
+        focused={field() === 1}
+        onInput={setName}
+        onSubmit={() => setField(2)}
+      />
+      <ModelPicker
+        theme={theme}
+        label="Models"
+        options={models()}
+        selected={selected()}
+        multiple
+        max={MULTI_RUN_MAX_MODELS}
+        focused={field() === 2}
+        onToggle={toggleModel}
+      />
+      <ChoiceField
+        theme={theme}
+        label="Workspace"
+        focused={field() === 3}
+        value={isolate()}
+        options={ISOLATION_OPTIONS}
+        onChange={setIsolate}
+      />
+      <Show when={isolate()}>
+        <TextField
+          theme={theme}
+          label="Start from"
+          initialValue=""
+          placeholder="Current HEAD"
+          focused={field() === 4}
+          onInput={setBaseRef}
+          onSubmit={() => void launch()}
+        />
+      </Show>
+    </DialogShell>
+  )
+}
+
+type DetailRow = { kind: 'entry'; entry: MultiRunEntry } | { kind: 'fusion'; fusion: MultiRunFusion }
+
+type Pane = 'runs' | 'details' | 'fuse'
+
+function MultiRunsDialog(props: MultiRunsDialogProps & { context: Context }) {
+  const theme: DialogTheme = props.context.theme.surface('dialog')
+  const [runs, setRuns] = createSignal<MultiRun[] | undefined>()
+  const [runIndex, setRunIndex] = createSignal(0)
+  const [rowIndex, setRowIndex] = createSignal(0)
+  const [pane, setPane] = createSignal<Pane>('runs')
+  const [fusionIds, setFusionIds] = createSignal<number[]>([])
+  const [pendingDiscard, setPendingDiscard] = createSignal<number | null>(null)
+  const [busy, setBusy] = createSignal<string | null>(null)
+  const [error, setError] = createSignal<string | null>(null)
+
+  const run = createMemo(() => runs()?.[runIndex()])
+  const rows = createMemo<DetailRow[]>(() => {
+    const current = run()
+    if (!current) return []
+    return [
+      ...current.entries.map((entry) => ({ kind: 'entry' as const, entry })),
+      ...current.fusions.map((fusion) => ({ kind: 'fusion' as const, fusion })),
+    ]
+  })
+
+  const load = async () => {
+    setBusy('Loading multi-runs…')
+    const result = await props.actions.list()
+    setBusy(null)
+    if (!result.ok) {
+      setError(result.error)
+      return
+    }
+    setError(null)
+    setRuns(result.value)
+    setRunIndex((index) => Math.min(index, Math.max(0, result.value.length - 1)))
+  }
+  onMount(load)
+
+  const selectRun = (index: number) => {
+    setRunIndex(index)
+    setRowIndex(0)
+    setFusionIds([])
+    setPendingDiscard(null)
+  }
+
+  const replaceRun = (updated: MultiRun) => setRuns((current) => current?.map((item) => (item.id === updated.id ? updated : item)))
+
+  const discard = async (entry: MultiRunEntry) => {
+    const current = run()
+    if (!current || busy()) return
+    if (pendingDiscard() !== entry.id) {
+      setPendingDiscard(entry.id)
+      return
+    }
+    setPendingDiscard(null)
+    setBusy(`Discarding ${entry.model}…`)
+    const result = await props.actions.discard(current, entry)
+    setBusy(null)
+    if (!result.ok) {
+      setError(result.error)
+      return
+    }
+    setError(null)
+    replaceRun(result.value)
+    setFusionIds((ids) => ids.filter((id) => id !== entry.id))
+  }
+
+  const startFusion = () => {
+    const current = run()
+    if (!current) return
+    const ids = fusionIds().length > 0 ? fusionIds() : startedEntries(current).slice(0, MULTI_RUN_MAX_MODELS).map((entry) => entry.id)
+    if (ids.length < MULTI_RUN_FUSION_MIN_SOURCES) {
+      setError(`Select at least ${MULTI_RUN_FUSION_MIN_SOURCES} started results to fuse (space selects).`)
+      return
+    }
+    setFusionIds(ids)
+    setError(null)
+    setPane('fuse')
+  }
+
+  const moveIndex = (count: number, set: (fn: (value: number) => number) => void, up: boolean) => {
+    if (count === 0) return
+    set((value) => (value + (up ? count - 1 : 1)) % count)
+  }
+
+  useKeyboard((event) => {
+    if (pane() === 'fuse') {
+      if (event.ctrl && event.name === 'b') {
+        event.preventDefault()
+        setPane('details')
+      }
+      return
+    }
+
+    const current = run()
+    const name = event.name
+    if (name === 'n') {
+      event.preventDefault()
+      props.newRun()
+      return
+    }
+    if (name === 'r') {
+      event.preventDefault()
+      void load()
+      return
+    }
+
+    if (pane() === 'runs') {
+      if (name === 'up' || name === 'down') {
+        event.preventDefault()
+        const count = runs()?.length ?? 0
+        if (count > 0) selectRun((runIndex() + (name === 'up' ? count - 1 : 1)) % count)
+        return
+      }
+      if ((name === 'return' || name === 'right') && current) {
+        event.preventDefault()
+        setPane('details')
+        return
+      }
+      if (name === 'f') {
+        event.preventDefault()
+        startFusion()
+      }
+      return
+    }
+
+    if (name === 'left') {
+      event.preventDefault()
+      setPendingDiscard(null)
+      setPane('runs')
+      return
+    }
+    if (name === 'up' || name === 'down') {
+      event.preventDefault()
+      setPendingDiscard(null)
+      moveIndex(rows().length, setRowIndex, name === 'up')
+      return
+    }
+    if (name === 'f') {
+      event.preventDefault()
+      startFusion()
+      return
+    }
+
+    const row = rows()[rowIndex()]
+    if (!row || !current) return
+    const sessionId = row.kind === 'entry' ? row.entry.sessionId : row.fusion.sessionId
+    if ((name === 'return' || name === 'o') && sessionId) {
+      event.preventDefault()
+      props.actions.open(sessionId)
+      props.context.ui.dialog.clear()
+      return
+    }
+    if (row.kind !== 'entry') return
+    if (name === 'space') {
+      event.preventDefault()
+      setFusionIds((ids) => toggleFusionSource(current, ids, row.entry.id))
+      return
+    }
+    if (name === 'd' && canDiscard(row.entry)) {
+      event.preventDefault()
+      void discard(row.entry)
+    }
+  })
+
+  const hints = createMemo(() => {
+    if (pane() === 'fuse') return [['tab', 'next field'], ['enter', 'pick model'], ['ctrl+s', 'fuse'], ['ctrl+b', 'back']] as const
+    if (pane() === 'runs') return [['↑↓', 'select run'], ['enter', 'open run'], ['f', 'fuse results'], ['n', 'new multi-run'], ['r', 'refresh']] as const
+    return [
+      ['↑↓', 'move'],
+      ['enter', 'open session'],
+      ['space', 'select for fusion'],
+      ['f', 'fuse'],
+      ['d', 'discard'],
+      ['←', 'runs'],
+    ] as const
+  })
+
+  return (
+    <DialogShell theme={theme} title="Multi-runs" busy={busy()} error={error()} hints={hints()}>
+      <Show
+        when={(runs()?.length ?? 0) > 0}
+        fallback={
+          <text fg={theme.text.muted}>{runs() ? 'No multi-runs for this repo yet. Press n to start one.' : 'Loading…'}</text>
+        }
+      >
+        <box flexDirection="row" gap={2}>
+          <box width={RUN_LIST_WIDTH} flexShrink={0}>
+            <For each={runs()}>
+              {(item, index) => {
+                const colors = () =>
+                  rowColors(theme, { active: index() === runIndex() && pane() === 'runs', chosen: index() === runIndex() })
+                return (
+                  <box backgroundColor={colors().background}>
+                    <text
+                      fg={colors().title}
+                      attributes={colors().bold ? TextAttributes.BOLD : undefined}
+                      wrapMode="none"
+                      truncate
+                    >
+                      {item.name}
+                    </text>
+                    <text fg={colors().detail} wrapMode="none" truncate>
+                      {runSummary(item)}
+                    </text>
+                  </box>
+                )
+              }}
+            </For>
+          </box>
+          <box flexGrow={1} flexShrink={1} gap={1}>
+            <Show when={run()}>
+              {(current) => (
+                <Show
+                  when={pane() === 'fuse'}
+                  fallback={
+                    <RunDetails
+                      theme={theme}
+                      run={current()}
+                      rows={rows()}
+                      rowIndex={rowIndex()}
+                      focused={pane() === 'details'}
+                      fusionIds={fusionIds()}
+                      pendingDiscard={pendingDiscard()}
+                    />
+                  }
+                >
+                  <FusionForm
+                    context={props.context}
+                    theme={theme}
+                    actions={props.actions}
+                    run={current()}
+                    entryIds={fusionIds()}
+                    onError={setError}
+                    onBusy={setBusy}
+                  />
+                </Show>
+              )}
+            </Show>
+          </box>
+        </box>
+      </Show>
+    </DialogShell>
+  )
+}
+
+function RunDetails(props: {
+  theme: DialogTheme
+  run: MultiRun
+  rows: DetailRow[]
+  rowIndex: number
+  focused: boolean
+  fusionIds: number[]
+  pendingDiscard: number | null
+}) {
+  return (
+    <box>
+      <text fg={props.theme.text.muted} wrapMode="none" truncate>
+        {props.run.prompt.replace(/\s+/g, ' ')}
+      </text>
+      <For each={props.rows}>
+        {(row, index) => {
+          const active = () => props.focused && index() === props.rowIndex
+          return (
+            <box flexDirection="row" gap={1} backgroundColor={rowColors(props.theme, { active: active() }).background}>
+              {row.kind === 'entry' ? (
+                <EntryRow theme={props.theme} entry={row.entry} active={active()} selected={props.fusionIds.includes(row.entry.id)} />
+              ) : (
+                <FusionRow theme={props.theme} fusion={row.fusion} active={active()} />
+              )}
+            </box>
+          )
+        }}
+      </For>
+      <Show when={props.pendingDiscard !== null}>
+        <text fg={props.theme.text.feedback.warning.base}>
+          Press d again to discard this run
+          {props.run.entries.find((entry) => entry.id === props.pendingDiscard)?.isolated ? ' and remove its worktree' : ''}. This cannot be
+          undone.
+        </text>
+      </Show>
+    </box>
+  )
+}
+
+function EntryRow(props: { theme: DialogTheme; entry: MultiRunEntry; active: boolean; selected: boolean }) {
+  const colors = () => rowColors(props.theme, { active: props.active, chosen: props.selected })
+  const statusColor = () =>
+    !props.active && props.entry.status === 'failed' ? props.theme.text.feedback.error.base : colors().detail
+  return (
+    <>
+      <text fg={colors().marker} flexShrink={0}>
+        {props.selected ? '[x]' : '[ ]'}
+      </text>
+      <text
+        fg={!props.active && props.entry.status === 'discarded' ? props.theme.text.muted : colors().title}
+        attributes={colors().bold ? TextAttributes.BOLD : undefined}
+        flexShrink={0}
+      >
+        {props.entry.model}
+      </text>
+      <text fg={statusColor()} wrapMode="none" truncate>
+        {formatEntryStatus(props.entry)}
+      </text>
+    </>
+  )
+}
+
+function FusionRow(props: { theme: DialogTheme; fusion: MultiRunFusion; active: boolean }) {
+  const colors = () => rowColors(props.theme, { active: props.active })
+  const statusColor = () =>
+    !props.active && props.fusion.status === 'failed' ? props.theme.text.feedback.error.base : colors().detail
+  return (
+    <>
+      <text fg={colors().detail} flexShrink={0}>
+        {'  ⇢'}
+      </text>
+      <text fg={colors().title} attributes={colors().bold ? TextAttributes.BOLD : undefined} flexShrink={0}>
+        fusion {props.fusion.model}
+      </text>
+      <text fg={statusColor()} wrapMode="none" truncate>
+        {[props.fusion.status, props.fusion.error].filter(Boolean).join(' · ')}
+      </text>
+    </>
+  )
+}
+
+function FusionForm(props: {
+  context: Context
+  theme: DialogTheme
+  actions: MultiRunActions
+  run: MultiRun
+  entryIds: number[]
+  onError: (message: string | null) => void
+  onBusy: (message: string | null) => void
+}) {
+  const [model, setModel] = createSignal('')
+  const [baseRef, setBaseRef] = createSignal(props.run.baseRef ?? '')
+  const [instructions, setInstructions] = createSignal('')
+  const [submitting, setSubmitting] = createSignal(false)
+  const models = useModelOptions(props.actions, props.onError)
+  const [field] = useFieldFocus(() => 3)
+  const sources = () => props.run.entries.filter((entry) => props.entryIds.includes(entry.id)).map((entry) => entry.model)
+
+  const fuse = async () => {
+    if (submitting()) return
+    setSubmitting(true)
+    props.onBusy('Starting fusion…')
+    props.onError(null)
+    const failure = await props.actions.fuse(props.run, {
+      entryIds: props.entryIds,
+      model: model(),
+      baseRef: baseRef(),
+      instructions: instructions(),
+    })
+    setSubmitting(false)
+    props.onBusy(null)
+    if (failure === null) {
+      props.context.ui.dialog.clear()
+      return
+    }
+    props.onError(failure)
+  }
+
+  useKeyboard((event) => {
+    if (!isSubmitKey(event)) return
+    event.preventDefault()
+    void fuse()
+  })
+
+  return (
+    <box gap={1}>
+      <text fg={props.theme.text.base}>
+        Fuse {props.entryIds.length} results: <span style={{ fg: props.theme.text.muted }}>{sources().join(', ')}</span>
+      </text>
+      <text fg={props.theme.text.muted}>The synthesis always runs in a new worktree.</text>
+      <ModelPicker
+        theme={props.theme}
+        label="Synthesis model"
+        options={models()}
+        selected={model() ? [model()] : []}
+        multiple={false}
+        max={1}
+        focused={field() === 0}
+        onToggle={setModel}
+      />
+      <TextField
+        theme={props.theme}
+        label="Start from"
+        initialValue={props.run.baseRef ?? ''}
+        placeholder="Current HEAD"
+        focused={field() === 1}
+        onInput={setBaseRef}
+      />
+      <TextAreaField
+        theme={props.theme}
+        label="Instructions (optional)"
+        initialValue=""
+        placeholder="Optional guidance for the synthesis"
+        height={3}
+        focused={field() === 2}
+        onInput={setInstructions}
+      />
+    </box>
+  )
+}
diff --git a/ocm-cli/src/tui-multi-run.ts b/ocm-cli/src/tui-multi-run.ts
new file mode 100644
index 000000000..4b099be5d
--- /dev/null
+++ b/ocm-cli/src/tui-multi-run.ts
@@ -0,0 +1,292 @@
+import { randomUUID } from 'node:crypto'
+import type { Context, ToastOptions } from '@opencode/plugin/tui/context'
+import {
+  FuseMultiRunRequestSchema,
+  FusionRecoveredDetailsSchema,
+  FusionUnavailableDetailsSchema,
+  LaunchMultiRunRequestSchema,
+  MULTI_RUN_FUSION_MIN_SOURCES,
+  MULTI_RUN_MAX_MODELS,
+  type FuseMultiRunRequest,
+  type LaunchMultiRunRequest,
+  type MultiRun,
+  type MultiRunEntry,
+  type MultiRunEntryStatus,
+} from '@opencode-manager/shared/schemas'
+import { formatOpenCodeModelRef } from '@opencode-manager/shared/opencode'
+import { ManagerApi, ManagerApiError, isManagerRouteMissing } from './manager-api.js'
+import { resolveManagerAuth } from './manager-auth.js'
+import type { ManagerAuthOk } from './manager-auth.js'
+import { slashArgument } from './tui-dialogs.js'
+import type { RemoteContext } from './remote-context.js'
+
+export const MULTI_RUN_ATTACH_REQUIRED =
+  'Multi-runs run on OpenCode Manager. Attach to a Manager repo with `ocm` first.'
+export const MULTI_RUN_ROUTE_MISSING = 'This OpenCode Manager does not expose multi-runs to ocm; upgrade the Manager.'
+
+export type ModelOption = {
+  title: string
+  description: string
+  value: string
+}
+
+export type ActionResult<Value> = { ok: true; value: Value } | { ok: false; error: string }
+
+export type LaunchFormInput = {
+  prompt: string
+  name: string
+  models: string[]
+  isolate: boolean
+  baseRef: string
+}
+
+export type FusionFormInput = {
+  entryIds: number[]
+  model: string
+  baseRef: string
+  instructions: string
+}
+
+/** Multi-run operations the dialogs call. Launch and fuse open the started sessions themselves and resolve to an error message, or null. */
+export type MultiRunActions = {
+  loadModels(): Promise<ActionResult<ModelOption[]>>
+  list(): Promise<ActionResult<MultiRun[]>>
+  launch(form: LaunchFormInput): Promise<string | null>
+  discard(run: MultiRun, entry: MultiRunEntry): Promise<ActionResult<MultiRun>>
+  fuse(run: MultiRun, form: FusionFormInput): Promise<string | null>
+  open(sessionId: string): void
+}
+
+export type MultiRunLaunchDialogProps = {
+  actions: MultiRunActions
+  initialPrompt: string
+}
+
+export type MultiRunsDialogProps = {
+  actions: MultiRunActions
+  newRun: () => void
+}
+
+export type MultiRunCommandDeps = {
+  remote: RemoteContext | undefined
+  showLaunchDialog: (props: MultiRunLaunchDialogProps) => void
+  showRunsDialog: (props: MultiRunsDialogProps) => void
+  createApi?: (auth: ManagerAuthOk) => ManagerApi
+}
+
+export async function listModelOptions(context: Context): Promise<ModelOption[]> {
+  await context.data.location.model.sync()
+  const models = context.data.location.model.list() ?? []
+  return models
+    .filter((model) => model.enabled && model.status !== 'deprecated')
+    .map((model) => {
+      const ref = formatOpenCodeModelRef({ providerID: model.providerID, id: model.id })
+      return { title: model.name, description: ref, value: ref }
+    })
+}
+
+/** Case-insensitive match of every whitespace-separated term against the model name or ref. */
+export function filterModelOptions(options: readonly ModelOption[], query: string): ModelOption[] {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean)
+  if (terms.length === 0) return [...options]
+  return options.filter((option) => {
+    const haystack = `${option.title} ${option.value}`.toLowerCase()
+    return terms.every((term) => haystack.includes(term))
+  })
+}
+
+export function openManagerSessions(context: Context, sessionIDs: string[]): void {
+  const first = sessionIDs[0]
+  if (!first) return
+
+  if (context.ui.tabs.enabled()) {
+    for (const sessionID of sessionIDs) context.ui.tabs.open(sessionID)
+    context.ui.tabs.focus(first)
+    return
+  }
+
+  context.ui.router.navigate({ type: 'session', sessionID: first })
+}
+
+export function defaultMultiRunName(prompt: string): string {
+  return prompt.trim().split('\n')[0]!.slice(0, 80).trim()
+}
+
+const ENTRY_STATUS_LABELS: Record<MultiRunEntryStatus, string> = {
+  starting: 'Starting',
+  started: 'Started',
+  failed: 'Failed',
+  discarded: 'Discarded',
+}
+
+export function formatEntryStatus(entry: MultiRunEntry): string {
+  const parts = [ENTRY_STATUS_LABELS[entry.status], entry.isolated ? 'isolated' : 'shared directory']
+  if (entry.error) parts.push(entry.error)
+  return parts.join(' · ')
+}
+
+export function runSummary(run: MultiRun): string {
+  const started = run.entries.filter((entry) => entry.status === 'started').length
+  return `${run.entries.length} models · ${started} started · ${run.fusions.length} fusions`
+}
+
+/** Started entries backed by a session: the sessions to open and the valid fusion sources. */
+export function startedEntries(run: MultiRun): (MultiRunEntry & { sessionId: string })[] {
+  return run.entries.filter(
+    (entry): entry is MultiRunEntry & { sessionId: string } => entry.status === 'started' && entry.sessionId !== null,
+  )
+}
+
+export function canDiscard(entry: MultiRunEntry): boolean {
+  return entry.status === 'started' || entry.status === 'failed'
+}
+
+/** Toggles an entry in the fusion selection, keeping run order and ignoring non-sources and selections past the model limit. */
+export function toggleFusionSource(run: MultiRun, selected: readonly number[], entryId: number): number[] {
+  const sourceIds = startedEntries(run).map((entry) => entry.id)
+  if (selected.includes(entryId)) return sourceIds.filter((id) => id !== entryId && selected.includes(id))
+  if (!sourceIds.includes(entryId) || selected.length >= MULTI_RUN_MAX_MODELS) return sourceIds.filter((id) => selected.includes(id))
+  return sourceIds.filter((id) => id === entryId || selected.includes(id))
+}
+
+export function parseLaunchForm(form: LaunchFormInput, repoId: number): ActionResult<LaunchMultiRunRequest> {
+  const prompt = form.prompt.trim()
+  if (!prompt) return { ok: false, error: 'Enter a prompt to send to every model.' }
+  const name = form.name.trim() || defaultMultiRunName(prompt)
+  if (form.models.length === 0) return { ok: false, error: 'Choose at least one model.' }
+  if (form.models.length > MULTI_RUN_MAX_MODELS) return { ok: false, error: `Choose at most ${MULTI_RUN_MAX_MODELS} models.` }
+
+  const baseRef = form.baseRef.trim()
+  const parsed = LaunchMultiRunRequestSchema.safeParse({
+    repoId,
+    name,
+    prompt,
+    models: form.models,
+    isolate: form.isolate,
+    ...(form.isolate && baseRef ? { baseRef } : {}),
+  })
+  if (!parsed.success) return { ok: false, error: parsed.error.issues[0]?.message ?? 'Invalid multi-run.' }
+  return { ok: true, value: parsed.data }
+}
+
+export function parseFusionForm(form: FusionFormInput, requestId: string): ActionResult<FuseMultiRunRequest> {
+  if (form.entryIds.length < MULTI_RUN_FUSION_MIN_SOURCES) {
+    return { ok: false, error: `Select at least ${MULTI_RUN_FUSION_MIN_SOURCES} started results to fuse.` }
+  }
+  if (!form.model) return { ok: false, error: 'Choose a synthesis model.' }
+
+  const instructions = form.instructions.trim()
+  const baseRef = form.baseRef.trim()
+  const parsed = FuseMultiRunRequestSchema.safeParse({
+    requestId,
+    entryIds: form.entryIds,
+    model: form.model,
+    ...(instructions ? { instructions } : {}),
+    ...(baseRef ? { baseRef } : {}),
+  })
+  if (!parsed.success) return { ok: false, error: parsed.error.issues[0]?.message ?? 'Invalid fusion.' }
+  return { ok: true, value: parsed.data }
+}
+
+/** Maps a Manager error to a message, plus the session of an earlier fusion attempt the Manager recovered instead. */
+export function describeMultiRunError(error: unknown): { message: string; recoveredSessionId?: string } {
+  if (isManagerRouteMissing(error)) return { message: MULTI_RUN_ROUTE_MISSING }
+  if (!(error instanceof ManagerApiError)) return { message: error instanceof Error ? error.message : String(error) }
+
+  const unavailable = FusionUnavailableDetailsSchema.safeParse(error.details)
+  if (unavailable.success && unavailable.data.unavailableSources.length > 0) {
+    return { message: unavailable.data.unavailableSources.map((source) => `${source.model}: ${source.message}`).join('\n') }
+  }
+
+  const recovered = FusionRecoveredDetailsSchema.safeParse(error.details)
+  const recoveredSessionId = recovered.success ? recovered.data.fusions[0]?.sessionId : undefined
+  if (recoveredSessionId) return { message: 'An earlier fusion attempt is already running.', recoveredSessionId }
+
+  return { message: error.message }
+}
+
+export function multiRunLaunchToast(run: MultiRun): ToastOptions {
+  const started = run.entries.filter((entry) => entry.status === 'started').length
+  const failed = run.entries.filter((entry) => entry.status === 'failed')
+  const lines = [`Launched ${run.name}: ${started}/${run.entries.length} started`]
+  for (const entry of failed) lines.push(`${entry.model}: ${entry.error ?? 'failed'}`)
+  return { variant: failed.length > 0 ? 'warning' : 'success', message: lines.join('\n') }
+}
+
+export async function runMultiRunCommand(context: Context, deps: MultiRunCommandDeps, input?: string): Promise<void> {
+  try {
+    const repoId = deps.remote?.repoId
+    if (!deps.remote || !repoId) {
+      context.ui.toast.show({ variant: 'error', message: MULTI_RUN_ATTACH_REQUIRED })
+      return
+    }
+
+    const auth = await resolveManagerAuth(deps.remote.managerUrl)
+    if (!auth.ok) {
+      context.ui.toast.show({ variant: 'error', message: auth.message })
+      return
+    }
+
+    const api = deps.createApi ? deps.createApi(auth) : new ManagerApi(auth.managerUrl, auth.token)
+    const actions = createMultiRunActions(context, api, repoId)
+    const prompt = slashArgument(input, 'multirun')
+
+    if (prompt) {
+      deps.showLaunchDialog({ actions, initialPrompt: prompt })
+      return
+    }
+
+    deps.showRunsDialog({ actions, newRun: () => deps.showLaunchDialog({ actions, initialPrompt: '' }) })
+  } catch (error) {
+    context.ui.toast.show({ variant: 'error', message: describeMultiRunError(error).message })
+  }
+}
+
+function createMultiRunActions(context: Context, api: ManagerApi, repoId: number): MultiRunActions {
+  const attempt = async <Value>(operation: () => Promise<Value>): Promise<ActionResult<Value>> => {
+    try {
+      return { ok: true, value: await operation() }
+    } catch (error) {
+      return { ok: false, error: describeMultiRunError(error).message }
+    }
+  }
+
+  return {
+    loadModels: () => attempt(() => listModelOptions(context)),
+    list: () => attempt(() => api.listMultiRuns(repoId)),
+    async launch(form) {
+      const parsed = parseLaunchForm(form, repoId)
+      if (!parsed.ok) return parsed.error
+      const result = await attempt(() => api.launchMultiRun(parsed.value))
+      if (!result.ok) return result.error
+      context.ui.toast.show(multiRunLaunchToast(result.value))
+      openManagerSessions(context, startedEntries(result.value).map((entry) => entry.sessionId))
+      return null
+    },
+    async discard(run, entry) {
+      const result = await attempt(() => api.discardMultiRunEntry(run.id, entry.id))
+      if (result.ok) context.ui.toast.show({ variant: 'success', message: `Discarded ${entry.model}` })
+      return result
+    },
+    async fuse(run, form) {
+      const requestId = randomUUID()
+      const parsed = parseFusionForm(form, requestId)
+      if (!parsed.ok) return parsed.error
+      try {
+        const updated = await api.fuseMultiRun(run.id, parsed.value)
+        const fusion = updated.fusions.find((candidate) => candidate.requestId === requestId)
+        if (fusion?.status === 'failed') return fusion.error ?? `Fusion with ${fusion.model} failed`
+        context.ui.toast.show({ variant: 'success', message: `Fusing with ${form.model}` })
+        if (fusion?.sessionId) openManagerSessions(context, [fusion.sessionId])
+        return null
+      } catch (error) {
+        const described = describeMultiRunError(error)
+        if (!described.recoveredSessionId) return described.message
+        context.ui.toast.show({ variant: 'info', message: `${described.message} Opened it instead.` })
+        openManagerSessions(context, [described.recoveredSessionId])
+        return null
+      }
+    },
+    open: (sessionId) => openManagerSessions(context, [sessionId]),
+  }
+}
diff --git a/ocm-cli/src/tui-ocm.ts b/ocm-cli/src/tui-ocm.ts
new file mode 100644
index 000000000..cc45297da
--- /dev/null
+++ b/ocm-cli/src/tui-ocm.ts
@@ -0,0 +1,126 @@
+import type { Context } from '@opencode/plugin/tui/context'
+import { resolveOpenCodeProjectId } from '@opencode-manager/shared/project-id'
+import { resolveManagerAuth } from './manager-auth.js'
+import { fetchRepos } from './manager-repos.js'
+import type { ManagerRepo } from './manager-repos.js'
+import { warmRepoProxy } from './repo-proxy.js'
+import { readState, writeState } from './state.js'
+import { confirmDialog, selectDialog } from './tui-dialogs.js'
+import { setPendingWarp } from './warp.js'
+import type { RemoteContext } from './remote-context.js'
+
+export type OcmSwitchDeps = {
+  remote: RemoteContext | undefined
+  cwd?: string
+}
+
+type SwitchChoice = { kind: 'repo'; repo: ManagerRepo } | { kind: 'local' }
+
+const MATCH_CATEGORY = 'Matches this directory'
+const REPO_CATEGORY = 'Manager repos'
+const LOCAL_CATEGORY = 'Local'
+
+/** Switches this TUI to another server: a Manager repo, or back to local opencode when attached. */
+export async function runOcmSwitch(context: Context, deps: OcmSwitchDeps): Promise<void> {
+  try {
+    const auth = await resolveManagerAuth(deps.remote?.managerUrl)
+    if (!auth.ok && !deps.remote) {
+      context.ui.toast.show({ variant: 'error', message: auth.message })
+      return
+    }
+
+    let repos: ManagerRepo[] = []
+    if (auth.ok) {
+      try {
+        repos = (await fetchRepos(auth.managerUrl, auth.token)).filter((repo) => repo.cloneStatus === 'ready')
+      } catch (error) {
+        if (!deps.remote) throw error
+      }
+    }
+    const choice = deps.remote
+      ? await chooseFromRemote(context, repos, deps.remote)
+      : auth.ok
+        ? await chooseFromLocal(context, repos, auth.managerUrl, deps.cwd ?? localDirectory(context))
+        : undefined
+    if (!choice) return
+
+    if (choice.kind === 'local') {
+      setPendingWarp({ kind: 'local' })
+      context.keymap.dispatch('app.exit')
+      return
+    }
+
+    if (!auth.ok) return
+
+    await warmRepoProxy(auth.managerUrl, auth.token, choice.repo.repoId)
+    rememberLastRepo(choice.repo)
+    setPendingWarp({
+      kind: 'attach',
+      target: { managerUrl: auth.managerUrl, token: auth.token, repoId: choice.repo.repoId, repoName: choice.repo.name },
+    })
+    context.keymap.dispatch('app.exit')
+  } catch (error) {
+    context.ui.toast.show({ variant: 'error', message: error instanceof Error ? error.message : String(error) })
+  }
+}
+
+async function chooseFromLocal(
+  context: Context,
+  repos: ManagerRepo[],
+  managerUrl: string,
+  directory: string,
+): Promise<SwitchChoice | undefined> {
+  const projectId = await resolveOpenCodeProjectId(directory)
+  const matches = projectId ? repos.filter((repo) => repo.projectId === projectId) : []
+
+  if (matches.length === 1) {
+    const repo = matches[0]!
+    const confirmed = await confirmDialog(context, {
+      title: 'Switch to OpenCode Manager',
+      message: `Exit this TUI and attach to ${repo.name} on ${new URL(managerUrl).host}?\n\nThe current session stays local. Use /ocm-move to bring it along.`,
+    })
+    return confirmed ? { kind: 'repo', repo } : undefined
+  }
+
+  if (repos.length === 0) {
+    context.ui.toast.show({ variant: 'error', message: 'The Manager has no ready repos. Run `ocm push --create` first.' })
+    return undefined
+  }
+
+  const matchIds = new Set(matches.map((repo) => repo.repoId))
+  return selectDialog<SwitchChoice>(context, 'Switch to Manager repo', [
+    ...matches.map((repo) => repoOption(repo, MATCH_CATEGORY)),
+    ...repos.filter((repo) => !matchIds.has(repo.repoId)).map((repo) => repoOption(repo, REPO_CATEGORY)),
+  ])
+}
+
+async function chooseFromRemote(context: Context, repos: ManagerRepo[], remote: RemoteContext): Promise<SwitchChoice | undefined> {
+  return selectDialog<SwitchChoice>(context, 'Switch server', [
+    { title: 'Local opencode', description: 'Leave the Manager and run opencode on this machine', value: { kind: 'local' }, category: LOCAL_CATEGORY },
+    ...repos.map((repo) => ({
+      ...repoOption(repo, REPO_CATEGORY),
+      ...(repo.repoId === remote.repoId ? { description: 'Current', disabled: true } : {}),
+    })),
+  ])
+}
+
+function repoOption(repo: ManagerRepo, category: string) {
+  return {
+    title: repo.name,
+    description: [repo.isWorktree ? 'worktree' : null, repo.branch].filter(Boolean).join(' · ') || undefined,
+    value: { kind: 'repo' as const, repo },
+    category,
+  }
+}
+
+function localDirectory(context: Context): string {
+  const route = context.ui.router.current()
+  const sessionDirectory = route.type === 'session' ? context.data.session.get(route.sessionID)?.location.directory : undefined
+  return sessionDirectory ?? process.cwd()
+}
+
+function rememberLastRepo(repo: ManagerRepo): void {
+  const state = readState()
+  if (!state) return
+  writeState({ ...state, lastRepoId: repo.repoId, lastRepoName: repo.name, lastRepoDir: repo.directory, lastRepoBranch: repo.branch })
+}
diff --git a/ocm-cli/src/tui-plugin.ts b/ocm-cli/src/tui-plugin.ts
index 633e1b119..e251eb577 100644
--- a/ocm-cli/src/tui-plugin.ts
+++ b/ocm-cli/src/tui-plugin.ts
@@ -1,7 +1,6 @@
 import type { Context } from '@opencode/plugin/tui/context'
-import { readInstallNotice, readState } from './state.js'
-import { getToken } from './internal-token-store.js'
-import { TokenStoreError } from './token-store.js'
+import { readInstallNotice } from './state.js'
+import { resolveManagerAuth } from './manager-auth.js'
 import { fetchRepos, toRemoteRepoSummaries } from './manager-repos.js'
 import { ManagerApi, ManagerApiError } from './manager-api.js'
 import type { MirrorTargetPlanResponse } from '@opencode-manager/shared/schemas'
@@ -16,10 +15,29 @@ import { setPendingWarp, runPendingWarp } from './warp.js'
 import { pushPhaseProgress, importProgress } from './move-progress.js'
 import { warmRepoProxy } from './repo-proxy.js'
 import type { MoveProgress } from './move-progress.js'
+import { runGoalCommand } from './tui-goal.js'
+import type { GoalDialogProps } from './tui-goal.js'
+import { runMultiRunCommand } from './tui-multi-run.js'
+import type { MultiRunLaunchDialogProps, MultiRunsDialogProps } from './tui-multi-run.js'
+import { runOcmSwitch } from './tui-ocm.js'
+import type { GoalStore } from './goal-store.js'
+import type { RemoteContext } from './remote-context.js'
 
 export type MoveProgressSetter = (progress: MoveProgress | null) => void
 
-export async function setupOcm(context: Context, setMoveProgress: MoveProgressSetter): Promise<() => void> {
+export type OcmDialogs = {
+  goal: (props: GoalDialogProps) => void
+  multiRunLaunch: (props: MultiRunLaunchDialogProps) => void
+  multiRuns: (props: MultiRunsDialogProps) => void
+}
+
+export type OcmFeatures = {
+  remote: RemoteContext | undefined
+  goals: GoalStore | undefined
+  dialogs: OcmDialogs
+}
+
+export async function setupOcm(context: Context, setMoveProgress: MoveProgressSetter, features: OcmFeatures): Promise<() => void> {
   showInstallNotice(context)
   context.ui.slot({
     append: 'app',
@@ -36,6 +54,43 @@ export async function setupOcm(context: Context, setMoveProgress: MoveProgressSe
             slash: { name: 'ocm-move' },
             run: () => runSessionMove(context, setMoveProgress),
           },
+          {
+            id: 'ocm.switch',
+            title: 'Switch server',
+            description: 'Attach this TUI to an OpenCode Manager repo, or go back to local opencode',
+            group: 'OpenCode Manager',
+            palette: true,
+            slash: { name: 'ocm' },
+            run: () => runOcmSwitch(context, { remote: features.remote }),
+          },
+          {
+            id: 'ocm.goal',
+            title: 'Goal',
+            description: 'Start, pause, resume, or cancel a Manager goal for this session',
+            group: 'OpenCode Manager',
+            palette: true,
+            slash: { name: 'goal', arguments: true },
+            run: (input) =>
+              runGoalCommand(context, { remote: features.remote, store: features.goals, showDialog: features.dialogs.goal }, input),
+          },
+          {
+            id: 'ocm.multirun',
+            title: 'Multi-run',
+            description: 'Run one prompt across several models on OpenCode Manager',
+            group: 'OpenCode Manager',
+            palette: true,
+            slash: { name: 'multirun', arguments: true },
+            run: (input) =>
+              runMultiRunCommand(
+                context,
+                {
+                  remote: features.remote,
+                  showLaunchDialog: features.dialogs.multiRunLaunch,
+                  showRunsDialog: features.dialogs.multiRuns,
+                },
+                input,
+              ),
+          },
         ],
       }))
       return null
@@ -116,26 +171,13 @@ async function runSessionMove(context: Context, setMoveProgress: MoveProgressSet
       return
     }
 
-    const state = readState()
-    if (!state?.managerUrl) {
-      context.ui.toast.show({ variant: 'error', message: 'No manager configured. Run `ocm login <url>` first.' })
-      return
-    }
-
-    let token: string | null
-    try {
-      token = await getToken(state.managerUrl)
-    } catch (err) {
-      const reason = err instanceof TokenStoreError ? err.message : String(err)
-      context.ui.toast.show({ variant: 'error', message: `Token store unavailable: ${reason}` })
-      return
-    }
-    if (!token) {
-      context.ui.toast.show({ variant: 'error', message: `No token stored. Run \`ocm login ${state.managerUrl}\`.` })
+    const auth = await resolveManagerAuth()
+    if (!auth.ok) {
+      context.ui.toast.show({ variant: 'error', message: auth.message })
       return
     }
 
-    const repos = await fetchRepos(state.managerUrl, token)
+    const repos = await fetchRepos(auth.managerUrl, auth.token)
     const plan = await prepareMirror(session.location.directory, toRemoteRepoSummaries(repos))
 
     if (plan.matched.length === 0) {
@@ -150,16 +192,16 @@ async function runSessionMove(context: Context, setMoveProgress: MoveProgressSet
     const matchedRepoId = matched.repoId
     const remoteRepo = repos.find((r) => r.repoId === matchedRepoId)!
 
-    await warmRepoProxy(state.managerUrl, token, matchedRepoId)
+    await warmRepoProxy(auth.managerUrl, auth.token, matchedRepoId)
 
-    const transfer = createManagerSessionTransfer(state.managerUrl, token)
+    const transfer = createManagerSessionTransfer(auth.managerUrl, auth.token)
     const blocker = await describeMoveBlocker(transfer, sessionID, session.parentID)
     if (blocker) {
       context.ui.toast.show({ variant: 'error', message: blocker })
       return
     }
 
-    const managerApi = new ManagerApi(state.managerUrl, token)
+    const managerApi = new ManagerApi(auth.managerUrl, auth.token)
     const target = await resolveMoveTarget(managerApi, matched, remoteRepo.directory, localBranch)
     const discardReasons = target.repoId === null ? [] : await describeRemoteDiscard(plan.repoRoot, managerApi, target.repoId)
 
@@ -199,8 +241,11 @@ async function runSessionMove(context: Context, setMoveProgress: MoveProgressSet
         setMoveProgress(null)
         const warp = await confirmDialog(context, { title: 'Attach to moved session?', message: 'Exit this TUI and attach to the moved session on the Manager now?' })
         if (warp) {
-          await warmRepoProxy(state.managerUrl, token, pushed.repoId)
-          setPendingWarp({ managerUrl: state.managerUrl, token, repoId: pushed.repoId, sessionID: result.sessionID, repoName: matched.name })
+          await warmRepoProxy(auth.managerUrl, auth.token, pushed.repoId)
+          setPendingWarp({
+            kind: 'attach',
+            target: { managerUrl: auth.managerUrl, token: auth.token, repoId: pushed.repoId, sessionID: result.sessionID, repoName: matched.name },
+          })
           context.keymap.dispatch('app.exit')
           return
         }
diff --git a/ocm-cli/src/tui.tsx b/ocm-cli/src/tui.tsx
index 2c7285101..931b5840f 100644
--- a/ocm-cli/src/tui.tsx
+++ b/ocm-cli/src/tui.tsx
@@ -2,9 +2,17 @@
 import { createSignal, createEffect, onCleanup, Show } from 'solid-js'
 import { Plugin } from '@opencode/plugin/tui'
 import { setupOcm } from './tui-plugin.js'
+import { showGoalDialog } from './tui-goal-dialog.js'
+import { showMultiRunLaunchDialog, showMultiRunsDialog } from './tui-multi-run-dialogs.js'
 import { formatMoveProgress } from './move-progress.js'
 import type { MoveProgress } from './move-progress.js'
 import { readRemoteContext } from './remote-context.js'
+import { createGoalStore, isOpenGoal } from './goal-store.js'
+import type { GoalStore } from './goal-store.js'
+import { formatGoalStatus, goalOutcomeToast } from './tui-goal.js'
+import { ManagerApi } from './manager-api.js'
+import { resolveManagerAuth } from './manager-auth.js'
+import type { SessionGoal } from '@opencode-manager/shared/schemas'
 
 const SPINNER_INTERVAL_MS = 80
 
@@ -44,6 +52,57 @@ export default Plugin.define({
       context.ui.slot({ append: 'home.footer.status', render: indicator })
     }
 
-    return setupOcm(context, setMoveProgress)
+    const goals = remote
+      ? createGoalStore({
+          load: async (sessionID) => {
+            const auth = await resolveManagerAuth(remote.managerUrl)
+            if (!auth.ok) throw new Error(auth.message)
+            return new ManagerApi(auth.managerUrl, auth.token).getLatestSessionGoal(sessionID)
+          },
+          onOutcome: (goal) => {
+            context.ui.toast.show({ ...goalOutcomeToast(goal), sessionID: goal.sessionId })
+          },
+        })
+      : undefined
+
+    const GoalLine = (props: { sessionID: string; store: GoalStore }) => {
+      const [goal, setGoal] = createSignal<SessionGoal | null>(null)
+      createEffect(() => {
+        const unsubscribe = props.store.watch(props.sessionID, (next) => setGoal(next))
+        onCleanup(unsubscribe)
+      })
+      const openGoal = () => {
+        const current = goal()
+        return current && isOpenGoal(current) ? current : null
+      }
+      return (
+        <Show when={openGoal()}>
+          {(current) => (
+            <box flexDirection="row" flexShrink={0}>
+              <text fg={current().status === 'active' ? context.theme.hue.accent[200] : context.theme.text.muted}>
+                {formatGoalStatus(current())}
+              </text>
+            </box>
+          )}
+        </Show>
+      )
+    }
+
+    if (goals) {
+      context.ui.slot({
+        append: 'session.composer.top',
+        render: (input) => <GoalLine sessionID={input.sessionID} store={goals} />,
+      })
+    }
+
+    return setupOcm(context, setMoveProgress, {
+      remote,
+      goals,
+      dialogs: {
+        goal: (props) => showGoalDialog(context, props),
+        multiRunLaunch: (props) => showMultiRunLaunchDialog(context, props),
+        multiRuns: (props) => showMultiRunsDialog(context, props),
+      },
+    })
   },
 })
diff --git a/ocm-cli/src/warp.ts b/ocm-cli/src/warp.ts
index f1de71851..1958f1209 100644
--- a/ocm-cli/src/warp.ts
+++ b/ocm-cli/src/warp.ts
@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process'
-import { buildRemoteAttachEnv } from './remote-context.js'
+import { buildRemoteAttachEnv, REMOTE_MANAGER_URL_ENV, REMOTE_REPO_ID_ENV, REMOTE_REPO_NAME_ENV } from './remote-context.js'
 import { repoProxyUrl } from './repo-proxy.js'
 
 export type AttachTarget = {
@@ -10,9 +10,7 @@ export type AttachTarget = {
   sessionID?: string
 }
 
-export type WarpTarget = AttachTarget & {
-  sessionID: string
-}
+export type PendingWarp = { kind: 'attach'; target: AttachTarget } | { kind: 'local' }
 
 export type AttachInvocation = {
   args: string[]
@@ -25,16 +23,18 @@ export type WarpSpawn = (
   options: { stdio: 'inherit'; env: NodeJS.ProcessEnv },
 ) => unknown
 
-let pending: WarpTarget | undefined
+const ATTACH_ENV_KEYS = ['OPENCODE_PASSWORD', REMOTE_MANAGER_URL_ENV, REMOTE_REPO_NAME_ENV, REMOTE_REPO_ID_ENV]
+
+let pending: PendingWarp | undefined
 
-export function setPendingWarp(target: WarpTarget): void {
-  pending = target
+export function setPendingWarp(warp: PendingWarp): void {
+  pending = warp
 }
 
-export function takePendingWarp(): WarpTarget | undefined {
-  const t = pending
+export function takePendingWarp(): PendingWarp | undefined {
+  const warp = pending
   pending = undefined
-  return t
+  return warp
 }
 
 export function buildAttachInvocation(target: AttachTarget): AttachInvocation {
@@ -42,15 +42,23 @@ export function buildAttachInvocation(target: AttachTarget): AttachInvocation {
   if (target.sessionID) args.push('--session', target.sessionID)
   return {
     args,
-    env: { ...process.env, OPENCODE_PASSWORD: target.token, ...buildRemoteAttachEnv(target.managerUrl, target.repoName) },
+    env: { ...process.env, OPENCODE_PASSWORD: target.token, ...buildRemoteAttachEnv(target.managerUrl, target.repoName, target.repoId) },
+  }
+}
+
+/** Builds a plain local `opencode` launch with every Manager attach variable removed. */
+export function buildLocalInvocation(env: NodeJS.ProcessEnv = process.env): AttachInvocation {
+  return {
+    args: [],
+    env: Object.fromEntries(Object.entries(env).filter(([key]) => !ATTACH_ENV_KEYS.includes(key))),
   }
 }
 
 export function runPendingWarp(spawn: WarpSpawn = spawnSync): void {
-  const target = takePendingWarp()
-  if (!target) return
+  const warp = takePendingWarp()
+  if (!warp) return
   try {
-    const { args, env } = buildAttachInvocation(target)
+    const { args, env } = warp.kind === 'attach' ? buildAttachInvocation(warp.target) : buildLocalInvocation()
     spawn('opencode', args, { stdio: 'inherit', env })
   } catch {
     void 0
diff --git a/ocm-cli/test/goal-store.test.ts b/ocm-cli/test/goal-store.test.ts
new file mode 100644
index 000000000..fefe5b06d
--- /dev/null
+++ b/ocm-cli/test/goal-store.test.ts
@@ -0,0 +1,318 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import type { SessionGoal } from '@opencode-manager/shared/schemas'
+import { createGoalStore, isOpenGoal, GOAL_POLL_INTERVAL_MS } from '../src/goal-store.js'
+
+function goal(overrides: Partial<SessionGoal> = {}): SessionGoal {
+  return {
+    id: 1,
+    sessionId: 'ses_a',
+    directory: '/repo',
+    objective: 'fix it',
+    status: 'active',
+    stopReason: null,
+    turnState: 'waiting',
+    continuationCount: 0,
+    maxContinuations: 5,
+    tokenBudget: null,
+    tokensUsed: 0,
+    consecutiveBlocked: 0,
+    lastVerdict: null,
+    lastReason: null,
+    createdAt: 1,
+    updatedAt: 1,
+    finishedAt: null,
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('isOpenGoal', () => {
+  it('accepts active and paused goals', () => {
+    expect(isOpenGoal(goal({ status: 'active' }))).toBe(true)
+    expect(isOpenGoal(goal({ status: 'paused' }))).toBe(true)
+  })
+
+  it('rejects terminal and missing goals', () => {
+    expect(isOpenGoal(goal({ status: 'completed' }))).toBe(false)
+    expect(isOpenGoal(goal({ status: 'blocked' }))).toBe(false)
+    expect(isOpenGoal(goal({ status: 'stopped' }))).toBe(false)
+    expect(isOpenGoal(null)).toBe(false)
+    expect(isOpenGoal(undefined)).toBe(false)
+  })
+})
+
+describe('createGoalStore', () => {
+  it('defaults the poll interval to the frontend refetch interval', () => {
+    expect(GOAL_POLL_INTERVAL_MS).toBe(3000)
+  })
+
+  it('loads once on watch and notifies the listener with the goal', async () => {
+    const active = goal()
+    const load = vi.fn().mockResolvedValue(active)
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+    const listener = vi.fn()
+
+    const unwatch = store.watch('ses_a', listener)
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(load).toHaveBeenCalledTimes(1)
+    expect(load).toHaveBeenCalledWith('ses_a')
+    expect(listener).toHaveBeenCalledWith(active)
+    unwatch()
+  })
+
+  it('notifies the listener with null when no goal exists', async () => {
+    const load = vi.fn().mockResolvedValue(null)
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+    const listener = vi.fn()
+
+    const unwatch = store.watch('ses_a', listener)
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(listener).toHaveBeenCalledWith(null)
+    unwatch()
+  })
+
+  it('polls while the goal is active', async () => {
+    const load = vi.fn().mockResolvedValue(goal({ status: 'active' }))
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    await vi.advanceTimersByTimeAsync(0)
+    expect(load).toHaveBeenCalledTimes(1)
+
+    await vi.advanceTimersByTimeAsync(100)
+    expect(load).toHaveBeenCalledTimes(2)
+
+    await vi.advanceTimersByTimeAsync(100)
+    expect(load).toHaveBeenCalledTimes(3)
+    unwatch()
+  })
+
+  it('stops polling when the goal is paused', async () => {
+    const load = vi.fn().mockResolvedValue(goal({ status: 'paused' }))
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    await vi.advanceTimersByTimeAsync(0)
+    await vi.advanceTimersByTimeAsync(1000)
+
+    expect(load).toHaveBeenCalledTimes(1)
+    unwatch()
+  })
+
+  it('stops polling when the goal is terminal', async () => {
+    const load = vi.fn().mockResolvedValue(goal({ status: 'completed' }))
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    await vi.advanceTimersByTimeAsync(0)
+    await vi.advanceTimersByTimeAsync(1000)
+
+    expect(load).toHaveBeenCalledTimes(1)
+    unwatch()
+  })
+
+  it('updates watchers immediately on set', async () => {
+    const load = vi.fn().mockResolvedValue(null)
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+    const listener = vi.fn()
+
+    const unwatch = store.watch('ses_a', listener)
+    await vi.advanceTimersByTimeAsync(0)
+    listener.mockClear()
+
+    const next = goal({ status: 'active' })
+    store.set(next)
+
+    expect(listener).toHaveBeenCalledWith(next)
+    unwatch()
+  })
+
+  it('starts polling when set installs an active goal', async () => {
+    const load = vi.fn().mockResolvedValue(null)
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    await vi.advanceTimersByTimeAsync(0)
+    expect(load).toHaveBeenCalledTimes(1)
+
+    store.set(goal({ status: 'active' }))
+    await vi.advanceTimersByTimeAsync(100)
+
+    expect(load).toHaveBeenCalledTimes(2)
+    unwatch()
+  })
+
+  it('reloads on demand through refresh', async () => {
+    const load = vi.fn().mockResolvedValue(null)
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+    const listener = vi.fn()
+
+    const unwatch = store.watch('ses_a', listener)
+    await vi.advanceTimersByTimeAsync(0)
+    listener.mockClear()
+
+    const next = goal()
+    load.mockResolvedValue(next)
+    await store.refresh('ses_a')
+
+    expect(load).toHaveBeenCalledTimes(2)
+    expect(listener).toHaveBeenCalledWith(next)
+    unwatch()
+  })
+
+  it('fires onOutcome once when a watched goal reaches a terminal status', async () => {
+    const active = goal({ status: 'active' })
+    const completed = goal({ status: 'completed' })
+    const load = vi.fn().mockResolvedValue(active)
+    const onOutcome = vi.fn()
+    const store = createGoalStore({ load, onOutcome, pollIntervalMs: 100 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    await vi.advanceTimersByTimeAsync(0)
+
+    load.mockResolvedValue(completed)
+    await vi.advanceTimersByTimeAsync(100)
+
+    expect(onOutcome).toHaveBeenCalledTimes(1)
+    expect(onOutcome).toHaveBeenCalledWith(completed)
+
+    await store.refresh('ses_a')
+    expect(onOutcome).toHaveBeenCalledTimes(1)
+    unwatch()
+  })
+
+  it('fires onOutcome when a paused goal is cancelled through set', async () => {
+    const paused = goal({ status: 'paused' })
+    const stopped = goal({ status: 'stopped', stopReason: 'cancelled' })
+    const load = vi.fn().mockResolvedValue(paused)
+    const onOutcome = vi.fn()
+    const store = createGoalStore({ load, onOutcome, pollIntervalMs: 100 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    await vi.advanceTimersByTimeAsync(0)
+
+    store.set(stopped)
+
+    expect(onOutcome).toHaveBeenCalledTimes(1)
+    expect(onOutcome).toHaveBeenCalledWith(stopped)
+    unwatch()
+  })
+
+  it('does not fire onOutcome for a goal that is already terminal', async () => {
+    const load = vi.fn().mockResolvedValue(goal({ status: 'completed' }))
+    const onOutcome = vi.fn()
+    const store = createGoalStore({ load, onOutcome, pollIntervalMs: 100 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(onOutcome).not.toHaveBeenCalled()
+    unwatch()
+  })
+
+  it('keeps the last goal and polling when a reload fails on an active goal', async () => {
+    const active = goal({ status: 'active' })
+    const load = vi.fn().mockResolvedValue(active)
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+    const listener = vi.fn()
+
+    const unwatch = store.watch('ses_a', listener)
+    await vi.advanceTimersByTimeAsync(0)
+
+    load.mockRejectedValue(new Error('offline'))
+    await vi.advanceTimersByTimeAsync(100)
+
+    expect(load).toHaveBeenCalledTimes(2)
+    expect(listener).toHaveBeenLastCalledWith(active)
+
+    await vi.advanceTimersByTimeAsync(100)
+    expect(load).toHaveBeenCalledTimes(3)
+    unwatch()
+  })
+
+  it('does not poll after an initial load failure', async () => {
+    const load = vi.fn().mockRejectedValue(new Error('offline'))
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+    const listener = vi.fn()
+
+    const unwatch = store.watch('ses_a', listener)
+    await vi.advanceTimersByTimeAsync(0)
+    await vi.advanceTimersByTimeAsync(1000)
+
+    expect(load).toHaveBeenCalledTimes(1)
+    expect(listener).not.toHaveBeenCalled()
+    unwatch()
+  })
+
+  it('stops polling when the last listener unsubscribes', async () => {
+    const load = vi.fn().mockResolvedValue(goal({ status: 'active' }))
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    await vi.advanceTimersByTimeAsync(0)
+    expect(load).toHaveBeenCalledTimes(1)
+
+    unwatch()
+    await vi.advanceTimersByTimeAsync(1000)
+
+    expect(load).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not resume polling when an in-flight load resolves after the last listener unsubscribes', async () => {
+    let resolveLoad: (goal: SessionGoal | null) => void = () => {}
+    const load = vi.fn(
+      () =>
+        new Promise<SessionGoal | null>((resolve) => {
+          resolveLoad = resolve
+        }),
+    )
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 20 })
+
+    const unwatch = store.watch('ses_a', vi.fn())
+    expect(load).toHaveBeenCalledTimes(1)
+
+    unwatch()
+    resolveLoad(goal({ status: 'active' }))
+    await vi.advanceTimersByTimeAsync(0)
+
+    await vi.advanceTimersByTimeAsync(200)
+    expect(load).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not start polling when set targets an unwatched session', async () => {
+    const load = vi.fn().mockResolvedValue(goal({ status: 'active' }))
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 20 })
+
+    store.set(goal({ status: 'active' }))
+    await vi.advanceTimersByTimeAsync(200)
+
+    expect(load).not.toHaveBeenCalled()
+  })
+
+  it('keeps polling while another listener remains', async () => {
+    const load = vi.fn().mockResolvedValue(goal({ status: 'active' }))
+    const store = createGoalStore({ load, onOutcome: vi.fn(), pollIntervalMs: 100 })
+    const second = vi.fn()
+
+    const unwatchFirst = store.watch('ses_a', vi.fn())
+    const unwatchSecond = store.watch('ses_a', second)
+    await vi.advanceTimersByTimeAsync(0)
+
+    unwatchFirst()
+    load.mockClear()
+    await vi.advanceTimersByTimeAsync(100)
+
+    expect(load).toHaveBeenCalledTimes(1)
+    expect(second).toHaveBeenCalled()
+    unwatchSecond()
+  })
+})
diff --git a/ocm-cli/test/manager-api.test.ts b/ocm-cli/test/manager-api.test.ts
new file mode 100644
index 000000000..dec686da7
--- /dev/null
+++ b/ocm-cli/test/manager-api.test.ts
@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { ManagerApi, ManagerApiError, isManagerRouteMissing } from '../src/manager-api.js'
+import type { MultiRun, SessionGoal } from '@opencode-manager/shared/schemas'
+
+const BASE_URL = 'http://localhost:5003'
+
+const goal: SessionGoal = {
+  id: 7,
+  sessionId: 'ses_1',
+  directory: '/repo',
+  objective: 'fix the flaky test',
+  status: 'active',
+  stopReason: null,
+  turnState: 'waiting',
+  continuationCount: 0,
+  maxContinuations: 10,
+  tokenBudget: null,
+  tokensUsed: 0,
+  consecutiveBlocked: 0,
+  lastVerdict: null,
+  lastReason: null,
+  createdAt: 1,
+  updatedAt: 2,
+  finishedAt: null,
+}
+
+const run: MultiRun = {
+  id: 3,
+  repoId: 1,
+  name: 'sweep',
+  prompt: 'hello',
+  isolated: true,
+  baseRef: null,
+  createdAt: 1,
+  entries: [],
+  fusions: [],
+}
+
+function okResponse(body: unknown) {
+  return { ok: true, status: 200, json: () => Promise.resolve(body), text: () => Promise.resolve('') }
+}
+
+function errorResponse(status: number, text: string) {
+  return { ok: false, status, json: () => Promise.reject(new Error('no json')), text: () => Promise.resolve(text) }
+}
+
+function stubFetch(response: unknown) {
+  const fetchMock = vi.fn().mockResolvedValue(response)
+  vi.stubGlobal('fetch', fetchMock)
+  return fetchMock
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('ManagerApi session goals', () => {
+  const api = new ManagerApi(BASE_URL, 'tok')
+
+  it('reads the latest goal for a session', async () => {
+    const fetchMock = stubFetch(okResponse({ goal }))
+
+    await expect(api.getLatestSessionGoal('ses_1')).resolves.toEqual(goal)
+    expect(fetchMock).toHaveBeenCalledWith(`${BASE_URL}/api/internal/session-goals?sessionId=ses_1`, {
+      headers: { Authorization: 'Bearer tok' },
+    })
+  })
+
+  it('returns null when the session has no goal', async () => {
+    stubFetch(okResponse({ goal: null }))
+
+    await expect(api.getLatestSessionGoal('ses_1')).resolves.toBeNull()
+  })
+
+  it('starts a goal', async () => {
+    const fetchMock = stubFetch(okResponse({ goal }))
+    const input = { sessionId: 'ses_1', directory: '/repo', objective: 'fix it' }
+
+    await expect(api.startSessionGoal(input)).resolves.toEqual(goal)
+    expect(fetchMock).toHaveBeenCalledWith(`${BASE_URL}/api/internal/session-goals`, {
+      method: 'POST',
+      headers: { Authorization: 'Bearer tok', 'Content-Type': 'application/json' },
+      body: JSON.stringify(input),
+    })
+  })
+
+  it('pauses, resumes, and cancels a goal through the action route', async () => {
+    const fetchMock = stubFetch(okResponse({ goal }))
+
+    await expect(api.pauseSessionGoal(7)).resolves.toEqual(goal)
+    await expect(api.resumeSessionGoal(7)).resolves.toEqual(goal)
+    await expect(api.cancelSessionGoal(7)).resolves.toEqual(goal)
+
+    expect(fetchMock).toHaveBeenNthCalledWith(1, `${BASE_URL}/api/internal/session-goals/7/pause`, {
+      method: 'POST',
+      headers: { Authorization: 'Bearer tok' },
+    })
+    expect(fetchMock).toHaveBeenNthCalledWith(2, `${BASE_URL}/api/internal/session-goals/7/resume`, {
+      method: 'POST',
+      headers: { Authorization: 'Bearer tok' },
+    })
+    expect(fetchMock).toHaveBeenNthCalledWith(3, `${BASE_URL}/api/internal/session-goals/7/cancel`, {
+      method: 'POST',
+      headers: { Authorization: 'Bearer tok' },
+    })
+  })
+
+  it('rejects a goal response that fails schema validation', async () => {
+    stubFetch(okResponse({ goal: { ...goal, status: 'bogus' } }))
+
+    await expect(api.getLatestSessionGoal('ses_1')).rejects.toThrow()
+  })
+})
+
+describe('ManagerApi multi-runs', () => {
+  const api = new ManagerApi(BASE_URL, 'tok')
+
+  it('lists runs for a repo', async () => {
+    const fetchMock = stubFetch(okResponse({ runs: [run] }))
+
+    await expect(api.listMultiRuns(1)).resolves.toEqual([run])
+    expect(fetchMock).toHaveBeenCalledWith(`${BASE_URL}/api/internal/multi-runs?repoId=1`, {
+      headers: { Authorization: 'Bearer tok' },
+    })
+  })
+
+  it('launches a run', async () => {
+    const fetchMock = stubFetch(okResponse({ run }))
+    const request = { repoId: 1, name: 'sweep', prompt: 'hello', models: ['a/b'], isolate: true }
+
+    await expect(api.launchMultiRun(request)).resolves.toEqual(run)
+    expect(fetchMock).toHaveBeenCalledWith(`${BASE_URL}/api/internal/multi-runs`, {
+      method: 'POST',
+      headers: { Authorization: 'Bearer tok', 'Content-Type': 'application/json' },
+      body: JSON.stringify(request),
+    })
+  })
+
+  it('fuses selected entries', async () => {
+    const fetchMock = stubFetch(okResponse({ run }))
+    const request = { requestId: '11111111-1111-4111-8111-111111111111', entryIds: [1, 2], model: 'a/b' }
+
+    await expect(api.fuseMultiRun(3, request)).resolves.toEqual(run)
+    expect(fetchMock).toHaveBeenCalledWith(`${BASE_URL}/api/internal/multi-runs/3/fusions`, {
+      method: 'POST',
+      headers: { Authorization: 'Bearer tok', 'Content-Type': 'application/json' },
+      body: JSON.stringify(request),
+    })
+  })
+
+  it('discards an entry', async () => {
+    const fetchMock = stubFetch(okResponse({ run }))
+
+    await expect(api.discardMultiRunEntry(3, 4)).resolves.toEqual(run)
+    expect(fetchMock).toHaveBeenCalledWith(`${BASE_URL}/api/internal/multi-runs/3/entries/4/discard`, {
+      method: 'POST',
+      headers: { Authorization: 'Bearer tok' },
+    })
+  })
+})
+
+describe('ManagerApiError', () => {
+  const api = new ManagerApi(BASE_URL, 'tok')
+
+  it('carries a JSON error code and details', async () => {
+    const details = { unavailableSources: [{ entryId: 1, model: 'a/b', reason: 'running', message: 'still running' }] }
+    stubFetch(errorResponse(409, JSON.stringify({ error: 'Fusion unavailable', details })))
+
+    const error = await api.fuseMultiRun(3, { requestId: '11111111-1111-4111-8111-111111111111', entryIds: [1, 2], model: 'a/b' }).catch((err) => err)
+
+    expect(error).toBeInstanceOf(ManagerApiError)
+    expect((error as ManagerApiError).status).toBe(409)
+    expect((error as ManagerApiError).code).toBe('Fusion unavailable')
+    expect((error as ManagerApiError).details).toEqual(details)
+  })
+
+  it('leaves details null when the error body has none', async () => {
+    stubFetch(errorResponse(400, JSON.stringify({ error: 'Invalid request' })))
+
+    const error = await api.listMultiRuns(1).catch((err) => err)
+
+    expect((error as ManagerApiError).details).toBeNull()
+  })
+})
+
+describe('isManagerRouteMissing', () => {
+  const api = new ManagerApi(BASE_URL, 'tok')
+
+  it('is true for a 404 with a non-JSON body', async () => {
+    stubFetch(errorResponse(404, '404 Not Found'))
+
+    const error = await api.listMultiRuns(1).catch((err) => err)
+
+    expect(isManagerRouteMissing(error)).toBe(true)
+  })
+
+  it('is false for a 404 with a JSON error body', async () => {
+    stubFetch(errorResponse(404, JSON.stringify({ error: 'Multi-run not found' })))
+
+    const error = await api.listMultiRuns(1).catch((err) => err)
+
+    expect(isManagerRouteMissing(error)).toBe(false)
+  })
+
+  it('is false for non-404 failures and unrelated errors', () => {
+    expect(isManagerRouteMissing(new ManagerApiError('x', 500, null, 'op'))).toBe(false)
+    expect(isManagerRouteMissing(new Error('nope'))).toBe(false)
+    expect(isManagerRouteMissing(null)).toBe(false)
+  })
+})
diff --git a/ocm-cli/test/manager-auth.test.ts b/ocm-cli/test/manager-auth.test.ts
new file mode 100644
index 000000000..b92b2d0e1
--- /dev/null
+++ b/ocm-cli/test/manager-auth.test.ts
@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { resolveManagerAuth } from '../src/manager-auth.js'
+import { TokenStoreError } from '../src/token-store.js'
+
+const mocks = vi.hoisted(() => ({
+  readState: vi.fn(),
+  getToken: vi.fn(),
+}))
+
+vi.mock('../src/state.js', () => ({ readState: mocks.readState }))
+vi.mock('../src/internal-token-store.js', () => ({ getToken: mocks.getToken }))
+
+beforeEach(() => {
+  vi.resetAllMocks()
+})
+
+describe('resolveManagerAuth', () => {
+  it('reports no manager when no state is stored', async () => {
+    mocks.readState.mockReturnValue(null)
+
+    await expect(resolveManagerAuth()).resolves.toEqual({
+      ok: false,
+      message: 'No manager configured. Run `ocm login <url>` first.',
+    })
+    expect(mocks.getToken).not.toHaveBeenCalled()
+  })
+
+  it('does not read state when given an explicit manager URL', async () => {
+    mocks.readState.mockReturnValue(null)
+    mocks.getToken.mockResolvedValue('tok')
+
+    await expect(resolveManagerAuth('https://mgr.example')).resolves.toEqual({
+      ok: true,
+      managerUrl: 'https://mgr.example',
+      token: 'tok',
+    })
+    expect(mocks.readState).not.toHaveBeenCalled()
+    expect(mocks.getToken).toHaveBeenCalledWith('https://mgr.example')
+  })
+
+  it('looks up the token under the normalized manager URL', async () => {
+    mocks.getToken.mockResolvedValue('tok')
+
+    await expect(resolveManagerAuth('  https://mgr.example//  ')).resolves.toEqual({
+      ok: true,
+      managerUrl: 'https://mgr.example',
+      token: 'tok',
+    })
+    expect(mocks.getToken).toHaveBeenCalledWith('https://mgr.example')
+  })
+
+  it('reports a token store failure', async () => {
+    mocks.readState.mockReturnValue({ managerUrl: 'https://mgr.example' })
+    mocks.getToken.mockRejectedValue(new TokenStoreError('keychain locked', 'keychain'))
+
+    await expect(resolveManagerAuth()).resolves.toEqual({
+      ok: false,
+      message: 'Token store unavailable: keychain locked',
+    })
+  })
+
+  it('reports a missing token', async () => {
+    mocks.readState.mockReturnValue({ managerUrl: 'https://mgr.example' })
+    mocks.getToken.mockResolvedValue(null)
+
+    await expect(resolveManagerAuth()).resolves.toEqual({
+      ok: false,
+      message: 'No token stored. Run `ocm login https://mgr.example`.',
+    })
+  })
+
+  it('resolves the manager URL and token', async () => {
+    mocks.readState.mockReturnValue({ managerUrl: 'https://mgr.example' })
+    mocks.getToken.mockResolvedValue('tok')
+
+    await expect(resolveManagerAuth()).resolves.toEqual({
+      ok: true,
+      managerUrl: 'https://mgr.example',
+      token: 'tok',
+    })
+  })
+})
diff --git a/ocm-cli/test/remote-context.test.ts b/ocm-cli/test/remote-context.test.ts
index d7a5255bb..8e259691d 100644
--- a/ocm-cli/test/remote-context.test.ts
+++ b/ocm-cli/test/remote-context.test.ts
@@ -1,16 +1,22 @@
 import { describe, it, expect } from 'vitest'
 import {
   REMOTE_MANAGER_URL_ENV,
+  REMOTE_REPO_ID_ENV,
   buildRemoteAttachEnv,
   readRemoteContext,
 } from '../src/remote-context.js'
 
 describe('buildRemoteAttachEnv', () => {
   it('round-trips through readRemoteContext', () => {
-    const env = buildRemoteAttachEnv('https://mgr.example.com', 'oc-manager')
+    const env = buildRemoteAttachEnv('https://mgr.example.com', 'oc-manager', 7)
     const result = readRemoteContext(env)
 
-    expect(result).toEqual({ managerHost: 'mgr.example.com', repoName: 'oc-manager' })
+    expect(result).toEqual({
+      managerUrl: 'https://mgr.example.com',
+      managerHost: 'mgr.example.com',
+      repoName: 'oc-manager',
+      repoId: 7,
+    })
   })
 })
 
@@ -43,4 +49,32 @@ describe('readRemoteContext', () => {
 
     expect(result?.repoName).toBeUndefined()
   })
+
+  it('returns the trimmed raw manager URL', () => {
+    const env = { [REMOTE_MANAGER_URL_ENV]: '  https://mgr.example.com  ' }
+    const result = readRemoteContext(env)
+
+    expect(result?.managerUrl).toBe('https://mgr.example.com')
+  })
+
+  it('returns undefined repoId when the repo id var is missing', () => {
+    const env = { [REMOTE_MANAGER_URL_ENV]: 'https://mgr.example.com' }
+    const result = readRemoteContext(env)
+
+    expect(result?.repoId).toBeUndefined()
+  })
+
+  it.each(['', 'abc', '0', '-1', '3.5'])('returns undefined repoId for %j', (value) => {
+    const env = { [REMOTE_MANAGER_URL_ENV]: 'https://mgr.example.com', [REMOTE_REPO_ID_ENV]: value }
+    const result = readRemoteContext(env)
+
+    expect(result?.repoId).toBeUndefined()
+  })
+
+  it('returns the numeric repoId when the repo id var is a positive integer', () => {
+    const env = { [REMOTE_MANAGER_URL_ENV]: 'https://mgr.example.com', [REMOTE_REPO_ID_ENV]: '42' }
+    const result = readRemoteContext(env)
+
+    expect(result?.repoId).toBe(42)
+  })
 })
\ No newline at end of file
diff --git a/ocm-cli/test/tui-dialogs.test.ts b/ocm-cli/test/tui-dialogs.test.ts
index 87727d2a7..ab334863b 100644
--- a/ocm-cli/test/tui-dialogs.test.ts
+++ b/ocm-cli/test/tui-dialogs.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest'
 import type { Context } from '@opencode/plugin/tui/context'
-import { confirmDialog, selectDialog } from '../src/tui-dialogs.js'
+import { confirmDialog, selectDialog, slashArgument } from '../src/tui-dialogs.js'
 
 function createFakeContext() {
   const confirm = vi.fn()
@@ -55,3 +55,25 @@ describe('selectDialog', () => {
     expect(await selectDialog(context, 'Pick', [{ title: 'X', value: 42 }])).toBeUndefined()
   })
 })
+
+describe('slashArgument', () => {
+  it('resolves an empty string for undefined input', () => {
+    expect(slashArgument(undefined, 'goal')).toBe('')
+  })
+
+  it('strips a leading slash token and trims the rest', () => {
+    expect(slashArgument('/goal  fix it ', 'goal')).toBe('fix it')
+  })
+
+  it('returns the trimmed argument when no slash token is present', () => {
+    expect(slashArgument('  fix it  ', 'goal')).toBe('fix it')
+  })
+
+  it('only strips a whole-token match', () => {
+    expect(slashArgument('/goalie x', 'goal')).toBe('/goalie x')
+  })
+
+  it('resolves an empty string when only the slash token is present', () => {
+    expect(slashArgument('/goal', 'goal')).toBe('')
+  })
+})
diff --git a/ocm-cli/test/tui-goal.test.ts b/ocm-cli/test/tui-goal.test.ts
new file mode 100644
index 000000000..3b209911e
--- /dev/null
+++ b/ocm-cli/test/tui-goal.test.ts
@@ -0,0 +1,395 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { Context } from '@opencode/plugin/tui/context'
+import type { SessionGoal } from '@opencode-manager/shared/schemas'
+import {
+  runGoalCommand,
+  formatGoalStatus,
+  goalOutcomeToast,
+  parseGoalForm,
+  GOALS_ATTACH_REQUIRED,
+  GOALS_ROUTE_MISSING,
+} from '../src/tui-goal.js'
+import type { GoalActions } from '../src/tui-goal.js'
+import { ManagerApiError } from '../src/manager-api.js'
+import type { ManagerApi } from '../src/manager-api.js'
+import { resolveManagerAuth } from '../src/manager-auth.js'
+import type { GoalStore } from '../src/goal-store.js'
+import type { RemoteContext } from '../src/remote-context.js'
+
+vi.mock('../src/manager-auth.js', () => ({
+  resolveManagerAuth: vi.fn(),
+}))
+
+const remote: RemoteContext = {
+  managerUrl: 'https://manager.example',
+  managerHost: 'manager.example',
+  repoName: 'repo',
+  repoId: 1,
+}
+
+function goal(overrides: Partial<SessionGoal> = {}): SessionGoal {
+  return {
+    id: 7,
+    sessionId: 'ses_a',
+    directory: '/repo',
+    objective: 'fix it',
+    status: 'active',
+    stopReason: null,
+    turnState: 'waiting',
+    continuationCount: 0,
+    maxContinuations: 5,
+    tokenBudget: null,
+    tokensUsed: 0,
+    consecutiveBlocked: 0,
+    lastVerdict: null,
+    lastReason: null,
+    createdAt: 1,
+    updatedAt: 1,
+    finishedAt: null,
+    ...overrides,
+  }
+}
+
+function createFakeContext(route: { type: string; sessionID?: string } = { type: 'session', sessionID: 'ses_a' }) {
+  const toast = vi.fn()
+  const select = vi.fn()
+  const dialogPrompt = vi.fn()
+  const sessionPrompt = vi.fn()
+  const status = vi.fn(() => 'idle')
+  const context = {
+    ui: {
+      router: { current: () => route },
+      toast: { show: toast },
+      dialog: { prompt: dialogPrompt, select },
+    },
+    data: {
+      session: {
+        get: () => ({ location: { directory: '/repo' } }),
+        status,
+      },
+    },
+    client: { session: { prompt: sessionPrompt } },
+  } as unknown as Context
+  return { context, toast, select, dialogPrompt, sessionPrompt, status }
+}
+
+function makeApi() {
+  return {
+    getLatestSessionGoal: vi.fn(async () => null as SessionGoal | null),
+    startSessionGoal: vi.fn(),
+    pauseSessionGoal: vi.fn(),
+    resumeSessionGoal: vi.fn(),
+    cancelSessionGoal: vi.fn(),
+  }
+}
+
+function makeStore() {
+  const set = vi.fn()
+  const store: GoalStore = {
+    watch: vi.fn(() => () => undefined),
+    set,
+    refresh: vi.fn(async () => undefined),
+  }
+  return { store, set }
+}
+
+function depsFor(api: ReturnType<typeof makeApi>, store: GoalStore, createApi = vi.fn(() => api as unknown as ManagerApi)) {
+  return { remote, store, createApi, showDialog: vi.fn() }
+}
+
+async function dialogActions(fake: ReturnType<typeof createFakeContext>, api: ReturnType<typeof makeApi>, store: GoalStore): Promise<GoalActions> {
+  const deps = depsFor(api, store)
+  await runGoalCommand(fake.context, deps, '/goal')
+  return deps.showDialog.mock.calls[0]![0].actions
+}
+
+const blankLimits = { maxTurns: '', tokenBudget: '' }
+
+beforeEach(() => {
+  vi.mocked(resolveManagerAuth).mockReset()
+  vi.mocked(resolveManagerAuth).mockResolvedValue({ ok: true, managerUrl: remote.managerUrl, token: 'tok' })
+})
+
+describe('formatGoalStatus', () => {
+  it('renders the outcome, shared turn and token labels, and objective', () => {
+    expect(
+      formatGoalStatus(goal({ status: 'active', continuationCount: 2, maxContinuations: 5, tokenBudget: 1000, tokensUsed: 250 })),
+    ).toBe(`Goal active · Turn 2/5 · 250/${(1000).toLocaleString()} tokens · fix it`)
+  })
+
+  it('omits the token budget when there is none', () => {
+    expect(formatGoalStatus(goal({ status: 'paused', tokenBudget: null }))).toBe('Goal paused · Turn 0/5 · fix it')
+  })
+})
+
+describe('goalOutcomeToast', () => {
+  it('maps completed to success with the last reason', () => {
+    expect(goalOutcomeToast(goal({ status: 'completed', lastReason: 'all green' }))).toEqual({
+      variant: 'success',
+      title: 'Goal completed',
+      message: 'all green',
+    })
+  })
+
+  it('maps blocked to error and falls back to the objective', () => {
+    expect(goalOutcomeToast(goal({ status: 'blocked', lastReason: null, objective: 'fix it' }))).toEqual({
+      variant: 'error',
+      title: 'Goal blocked',
+      message: 'fix it',
+    })
+  })
+
+  it('maps stopped to warning and prefers the stop reason label', () => {
+    expect(goalOutcomeToast(goal({ status: 'stopped', stopReason: 'cancelled' }))).toEqual({
+      variant: 'warning',
+      title: 'Goal stopped',
+      message: 'Cancelled',
+    })
+  })
+})
+
+describe('parseGoalForm', () => {
+  it('trims the objective and leaves blank limits to the Manager defaults', () => {
+    expect(parseGoalForm({ objective: '  fix it ', ...blankLimits }, 'ses_a', '/repo')).toEqual({
+      ok: true,
+      request: { sessionId: 'ses_a', directory: '/repo', objective: 'fix it' },
+    })
+  })
+
+  it('passes explicit limits through', () => {
+    expect(parseGoalForm({ objective: 'fix it', maxTurns: ' 12 ', tokenBudget: '50000' }, 'ses_a', '/repo')).toEqual({
+      ok: true,
+      request: { sessionId: 'ses_a', directory: '/repo', objective: 'fix it', maxContinuations: 12, tokenBudget: 50000 },
+    })
+  })
+
+  it('rejects a blank objective and out-of-range or non-numeric limits', () => {
+    expect(parseGoalForm({ objective: ' ', ...blankLimits }, 'ses_a', '/repo')).toEqual({
+      ok: false,
+      error: 'Describe what this session should accomplish.',
+    })
+    for (const maxTurns of ['0', '201', 'ten', '1.5']) {
+      expect(parseGoalForm({ objective: 'x', maxTurns, tokenBudget: '' }, 'ses_a', '/repo')).toEqual({
+        ok: false,
+        error: 'Max turns must be a whole number from 1 to 200.',
+      })
+    }
+    for (const tokenBudget of ['0', '-5', 'lots']) {
+      expect(parseGoalForm({ objective: 'x', maxTurns: '', tokenBudget }, 'ses_a', '/repo')).toEqual({
+        ok: false,
+        error: 'Token budget must be a positive whole number.',
+      })
+    }
+  })
+})
+
+describe('runGoalCommand', () => {
+  it('refuses when not attached to a Manager or without a goal store', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const { store } = makeStore()
+    const detached = { ...depsFor(api, store), remote: undefined }
+    const storeless = { ...depsFor(api, store), store: undefined }
+
+    await runGoalCommand(fake.context, detached, '/goal fix it')
+    await runGoalCommand(fake.context, storeless, '/goal fix it')
+
+    expect(fake.toast).toHaveBeenCalledTimes(2)
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'error', message: GOALS_ATTACH_REQUIRED })
+    expect(detached.createApi).not.toHaveBeenCalled()
+  })
+
+  it('refuses outside a session', async () => {
+    const fake = createFakeContext({ type: 'home' })
+    const { store } = makeStore()
+    const deps = depsFor(makeApi(), store)
+
+    await runGoalCommand(fake.context, deps, '/goal fix it')
+
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'error', message: 'Not in a session' })
+    expect(deps.createApi).not.toHaveBeenCalled()
+  })
+
+  it('reports an auth failure without calling the API', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const { store } = makeStore()
+    vi.mocked(resolveManagerAuth).mockResolvedValue({ ok: false, message: 'No token stored. Run `ocm login https://manager.example`.' })
+
+    await runGoalCommand(fake.context, depsFor(api, store), '/goal fix it')
+
+    expect(fake.toast).toHaveBeenCalledWith({
+      variant: 'error',
+      message: 'No token stored. Run `ocm login https://manager.example`.',
+    })
+    expect(api.getLatestSessionGoal).not.toHaveBeenCalled()
+  })
+
+  it('starts a goal directly from the slash argument and sends the objective as the next message', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const started = goal({ status: 'active' })
+    api.startSessionGoal.mockResolvedValue(started)
+    const { store, set } = makeStore()
+    const deps = depsFor(api, store)
+    fake.sessionPrompt.mockResolvedValue(undefined)
+
+    await runGoalCommand(fake.context, deps, '/goal Fix the flaky test')
+
+    expect(api.startSessionGoal).toHaveBeenCalledWith({ sessionId: 'ses_a', directory: '/repo', objective: 'Fix the flaky test' })
+    expect(set).toHaveBeenCalledWith(started)
+    expect(fake.sessionPrompt).toHaveBeenCalledWith({ sessionID: 'ses_a', text: 'Fix the flaky test', delivery: undefined })
+    expect(api.startSessionGoal.mock.invocationCallOrder[0]).toBeLessThan(fake.sessionPrompt.mock.invocationCallOrder[0])
+    expect(deps.showDialog).not.toHaveBeenCalled()
+  })
+
+  it('queues the objective while the session is running', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.startSessionGoal.mockResolvedValue(goal())
+    const { store } = makeStore()
+    fake.status.mockReturnValue('running')
+    fake.sessionPrompt.mockResolvedValue(undefined)
+
+    await runGoalCommand(fake.context, depsFor(api, store), '/goal Fix it')
+
+    expect(fake.sessionPrompt).toHaveBeenCalledWith(expect.objectContaining({ delivery: 'queue' }))
+  })
+
+  it('opens the dialog with the latest goal when the command has no objective', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const last = goal({ status: 'completed' })
+    api.getLatestSessionGoal.mockResolvedValue(last)
+    const { store } = makeStore()
+    const deps = depsFor(api, store)
+
+    await runGoalCommand(fake.context, deps, '/goal')
+
+    expect(deps.showDialog).toHaveBeenCalledWith({
+      sessionID: 'ses_a',
+      store,
+      initialGoal: last,
+      initialObjective: '',
+      actions: expect.any(Object),
+    })
+    expect(api.startSessionGoal).not.toHaveBeenCalled()
+  })
+
+  it('opens the dialog instead of starting when a goal is already open', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const active = goal({ status: 'active' })
+    api.getLatestSessionGoal.mockResolvedValue(active)
+    const { store } = makeStore()
+    const deps = depsFor(api, store)
+
+    await runGoalCommand(fake.context, deps, '/goal something else')
+
+    expect(deps.showDialog).toHaveBeenCalledWith(expect.objectContaining({ initialGoal: active, initialObjective: 'something else' }))
+    expect(api.startSessionGoal).not.toHaveBeenCalled()
+  })
+
+  it('reports Manager errors, including an outdated Manager', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const { store } = makeStore()
+    api.getLatestSessionGoal.mockRejectedValueOnce(new ManagerApiError('read failed', 500, 'boom', 'read session goal'))
+    api.getLatestSessionGoal.mockRejectedValueOnce(new ManagerApiError('not found', 404, null, 'read session goal'))
+
+    await runGoalCommand(fake.context, depsFor(api, store), '/goal fix it')
+    await runGoalCommand(fake.context, depsFor(api, store), '/goal fix it')
+
+    expect(fake.toast).toHaveBeenNthCalledWith(1, { variant: 'error', message: 'read failed' })
+    expect(fake.toast).toHaveBeenNthCalledWith(2, { variant: 'error', message: GOALS_ROUTE_MISSING })
+  })
+})
+
+describe('goal dialog actions', () => {
+  it('starts a goal with explicit limits', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.startSessionGoal.mockResolvedValue(goal())
+    fake.sessionPrompt.mockResolvedValue(undefined)
+    const { store } = makeStore()
+    const actions = await dialogActions(fake, api, store)
+
+    await expect(actions.start({ objective: 'fix it', maxTurns: '8', tokenBudget: '' })).resolves.toBeNull()
+
+    expect(api.startSessionGoal).toHaveBeenCalledWith({ sessionId: 'ses_a', directory: '/repo', objective: 'fix it', maxContinuations: 8 })
+  })
+
+  it('returns a validation error without calling the API', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const { store } = makeStore()
+    const actions = await dialogActions(fake, api, store)
+
+    await expect(actions.start({ objective: 'fix it', maxTurns: '0', tokenBudget: '' })).resolves.toBe(
+      'Max turns must be a whole number from 1 to 200.',
+    )
+    expect(api.startSessionGoal).not.toHaveBeenCalled()
+  })
+
+  it('cancels the goal and explains why when sending the objective fails', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const started = goal({ status: 'active' })
+    const cancelled = goal({ status: 'stopped', stopReason: 'cancelled' })
+    api.startSessionGoal.mockResolvedValue(started)
+    api.cancelSessionGoal.mockResolvedValue(cancelled)
+    fake.sessionPrompt.mockRejectedValue(new Error('send failed'))
+    const { store, set } = makeStore()
+    const actions = await dialogActions(fake, api, store)
+
+    await expect(actions.start({ objective: 'fix it', ...blankLimits })).resolves.toBe(
+      'The goal was cancelled because the objective could not be sent: send failed',
+    )
+    expect(api.cancelSessionGoal).toHaveBeenCalledWith(started.id)
+    expect(set).toHaveBeenLastCalledWith(cancelled)
+  })
+
+  it('still reports the send failure when cancelling fails', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.startSessionGoal.mockResolvedValue(goal())
+    api.cancelSessionGoal.mockRejectedValue(new Error('cancel failed'))
+    fake.sessionPrompt.mockRejectedValue(new Error('send failed'))
+    const { store, set } = makeStore()
+    const actions = await dialogActions(fake, api, store)
+
+    await expect(actions.start({ objective: 'fix it', ...blankLimits })).resolves.toMatch(/send failed$/)
+    expect(set).toHaveBeenCalledTimes(1)
+  })
+
+  it('pauses, resumes, and cancels through the Manager and updates the store', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const paused = goal({ status: 'paused' })
+    const resumed = goal({ status: 'active' })
+    const stopped = goal({ status: 'stopped', stopReason: 'cancelled' })
+    api.pauseSessionGoal.mockResolvedValue(paused)
+    api.resumeSessionGoal.mockResolvedValue(resumed)
+    api.cancelSessionGoal.mockResolvedValue(stopped)
+    const { store, set } = makeStore()
+    const actions = await dialogActions(fake, api, store)
+
+    await expect(actions.pause(goal())).resolves.toBeNull()
+    await expect(actions.resume(paused)).resolves.toBeNull()
+    await expect(actions.cancel(resumed)).resolves.toBeNull()
+
+    expect(api.pauseSessionGoal).toHaveBeenCalledWith(7)
+    expect(set.mock.calls.map((call) => call[0])).toEqual([paused, resumed, stopped])
+  })
+
+  it('returns a goal action failure as a message', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.pauseSessionGoal.mockRejectedValue(new ManagerApiError('pause session goal failed (409): not active', 409, 'x', 'pause session goal'))
+    const { store, set } = makeStore()
+    const actions = await dialogActions(fake, api, store)
+
+    await expect(actions.pause(goal())).resolves.toBe('pause session goal failed (409): not active')
+    expect(set).not.toHaveBeenCalled()
+  })
+})
diff --git a/ocm-cli/test/tui-multi-run.test.ts b/ocm-cli/test/tui-multi-run.test.ts
new file mode 100644
index 000000000..803503c69
--- /dev/null
+++ b/ocm-cli/test/tui-multi-run.test.ts
@@ -0,0 +1,541 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { Context } from '@opencode/plugin/tui/context'
+import type { ModelInfo } from '@opencode/client'
+import type { MultiRun, MultiRunEntry } from '@opencode-manager/shared/schemas'
+import {
+  describeMultiRunError,
+  filterModelOptions,
+  formatEntryStatus,
+  listModelOptions,
+  openManagerSessions,
+  parseFusionForm,
+  parseLaunchForm,
+  runMultiRunCommand,
+  runSummary,
+  toggleFusionSource,
+  MULTI_RUN_ATTACH_REQUIRED,
+  MULTI_RUN_ROUTE_MISSING,
+} from '../src/tui-multi-run.js'
+import type { LaunchFormInput, MultiRunActions } from '../src/tui-multi-run.js'
+import { ManagerApiError } from '../src/manager-api.js'
+import type { ManagerApi } from '../src/manager-api.js'
+import { resolveManagerAuth } from '../src/manager-auth.js'
+import type { RemoteContext } from '../src/remote-context.js'
+import type { MultiRunFusion } from '@opencode-manager/shared/schemas'
+
+vi.mock('../src/manager-auth.js', () => ({
+  resolveManagerAuth: vi.fn(),
+}))
+
+const remote: RemoteContext = {
+  managerUrl: 'https://manager.example',
+  managerHost: 'manager.example',
+  repoName: 'repo',
+  repoId: 1,
+}
+
+function model(overrides: Partial<ModelInfo> = {}): ModelInfo {
+  return {
+    id: 'gpt-5',
+    modelID: 'gpt-5',
+    providerID: 'openai',
+    name: 'GPT-5',
+    capabilities: {} as ModelInfo['capabilities'],
+    variants: [],
+    time: { released: 0 },
+    cost: [],
+    status: 'active',
+    enabled: true,
+    limit: { context: 0, output: 0 },
+    ...overrides,
+  } as ModelInfo
+}
+
+function entry(overrides: Partial<MultiRunEntry> = {}): MultiRunEntry {
+  return {
+    id: 1,
+    model: 'openai/gpt-5',
+    status: 'started',
+    sessionId: 'ses_1',
+    directory: '/work/1',
+    isolated: true,
+    error: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...overrides,
+  }
+}
+
+function multiRun(overrides: Partial<MultiRun> = {}): MultiRun {
+  return {
+    id: 3,
+    repoId: 1,
+    name: 'sweep',
+    prompt: 'hello',
+    isolated: true,
+    baseRef: null,
+    createdAt: 1,
+    entries: [entry()],
+    fusions: [],
+    ...overrides,
+  }
+}
+
+function fusion(overrides: Partial<MultiRunFusion> = {}): MultiRunFusion {
+  return {
+    id: 9,
+    requestId: 'req-1',
+    model: 'anthropic/claude',
+    instructions: null,
+    isolated: true,
+    baseRef: null,
+    status: 'started',
+    sessionId: 'ses_f',
+    directory: '/work/f',
+    error: null,
+    sources: [],
+    createdAt: 1,
+    updatedAt: 1,
+    ...overrides,
+  }
+}
+
+function createFakeContext() {
+  const toast = vi.fn()
+  const prompt = vi.fn()
+  const select = vi.fn()
+  const confirm = vi.fn()
+  const open = vi.fn()
+  const focus = vi.fn()
+  const enabled = vi.fn(() => true)
+  const navigate = vi.fn()
+  const sync = vi.fn(async () => undefined)
+  const list = vi.fn(() => [] as ModelInfo[])
+  const context = {
+    ui: {
+      toast: { show: toast },
+      dialog: { prompt, select, confirm },
+      tabs: { enabled, open, focus },
+      router: { navigate, current: () => ({ type: 'session', sessionID: 'ses_a' }) },
+    },
+    data: { location: { model: { sync, list } } },
+  } as unknown as Context
+  return { context, toast, prompt, select, confirm, open, focus, enabled, navigate, sync, list }
+}
+
+function makeApi() {
+  return {
+    launchMultiRun: vi.fn(async () => multiRun()),
+    listMultiRuns: vi.fn(async () => [] as MultiRun[]),
+    fuseMultiRun: vi.fn(async () => multiRun()),
+    discardMultiRunEntry: vi.fn(async () => multiRun()),
+  }
+}
+
+function depsFor(api: ReturnType<typeof makeApi>, createApi = vi.fn(() => api as unknown as ManagerApi)) {
+  return { remote, createApi, showLaunchDialog: vi.fn(), showRunsDialog: vi.fn() }
+}
+
+async function launchActions(fake: ReturnType<typeof createFakeContext>, api: ReturnType<typeof makeApi>): Promise<MultiRunActions> {
+  const deps = depsFor(api)
+  await runMultiRunCommand(fake.context, deps, '/multirun hello')
+  return deps.showLaunchDialog.mock.calls[0]![0].actions
+}
+
+const UUID = '7f1c9d2e-3b4a-4c5d-8e6f-0a1b2c3d4e5f'
+
+function launchForm(overrides: Partial<LaunchFormInput> = {}): LaunchFormInput {
+  return { prompt: 'fix the flaky test', name: '', models: ['openai/gpt-5'], isolate: true, baseRef: '', ...overrides }
+}
+
+beforeEach(() => {
+  vi.mocked(resolveManagerAuth).mockReset()
+  vi.mocked(resolveManagerAuth).mockResolvedValue({ ok: true, managerUrl: remote.managerUrl, token: 'tok' })
+})
+
+describe('listModelOptions', () => {
+  it('syncs then maps enabled, non-deprecated models to refs', async () => {
+    const fake = createFakeContext()
+    fake.list.mockReturnValue([
+      model({ providerID: 'openai', id: 'gpt-5', name: 'GPT-5' }),
+      model({ providerID: 'anthropic', id: 'claude', name: 'Claude' }),
+      model({ providerID: 'openai', id: 'old', name: 'Old', status: 'deprecated' }),
+      model({ providerID: 'openai', id: 'off', name: 'Off', enabled: false }),
+    ])
+
+    await expect(listModelOptions(fake.context)).resolves.toEqual([
+      { title: 'GPT-5', description: 'openai/gpt-5', value: 'openai/gpt-5' },
+      { title: 'Claude', description: 'anthropic/claude', value: 'anthropic/claude' },
+    ])
+    expect(fake.sync).toHaveBeenCalledTimes(1)
+    expect(fake.sync.mock.invocationCallOrder[0]).toBeLessThan(fake.list.mock.invocationCallOrder[0])
+  })
+
+  it('tolerates a model list that is not loaded yet', async () => {
+    const fake = createFakeContext()
+    fake.list.mockReturnValue(undefined as unknown as ModelInfo[])
+
+    await expect(listModelOptions(fake.context)).resolves.toEqual([])
+  })
+})
+
+describe('openManagerSessions', () => {
+  it('opens a tab per session then focuses the first when tabs are enabled', () => {
+    const fake = createFakeContext()
+
+    openManagerSessions(fake.context, ['ses_1', 'ses_2'])
+
+    expect(fake.open).toHaveBeenNthCalledWith(1, 'ses_1')
+    expect(fake.open).toHaveBeenNthCalledWith(2, 'ses_2')
+    expect(fake.focus).toHaveBeenCalledWith('ses_1')
+    expect(fake.navigate).not.toHaveBeenCalled()
+  })
+
+  it('navigates to the first session when tabs are disabled', () => {
+    const fake = createFakeContext()
+    fake.enabled.mockReturnValue(false)
+
+    openManagerSessions(fake.context, ['ses_1', 'ses_2'])
+
+    expect(fake.navigate).toHaveBeenCalledWith({ type: 'session', sessionID: 'ses_1' })
+    expect(fake.open).not.toHaveBeenCalled()
+    expect(fake.focus).not.toHaveBeenCalled()
+  })
+
+  it('does nothing for an empty session list', () => {
+    const fake = createFakeContext()
+
+    openManagerSessions(fake.context, [])
+
+    expect(fake.enabled).not.toHaveBeenCalled()
+    expect(fake.open).not.toHaveBeenCalled()
+    expect(fake.focus).not.toHaveBeenCalled()
+    expect(fake.navigate).not.toHaveBeenCalled()
+  })
+})
+
+describe('formatEntryStatus', () => {
+  it('describes the status, isolation and error', () => {
+    expect(formatEntryStatus(entry({ status: 'started', isolated: true }))).toBe('Started · isolated')
+    expect(formatEntryStatus(entry({ status: 'failed', isolated: false, error: 'model unavailable' }))).toBe(
+      'Failed · shared directory · model unavailable',
+    )
+    expect(formatEntryStatus(entry({ status: 'discarded', isolated: true }))).toBe('Discarded · isolated')
+  })
+})
+
+describe('filterModelOptions', () => {
+  const options = [
+    { title: 'GPT-5', description: 'openai/gpt-5', value: 'openai/gpt-5' },
+    { title: 'Claude Sonnet', description: 'anthropic/claude-sonnet', value: 'anthropic/claude-sonnet' },
+  ]
+
+  it('returns every option for a blank query', () => {
+    expect(filterModelOptions(options, '  ')).toEqual(options)
+  })
+
+  it('matches every term against the name or ref, case-insensitively', () => {
+    expect(filterModelOptions(options, 'ANTHROPIC son')).toEqual([options[1]])
+    expect(filterModelOptions(options, 'gpt claude')).toEqual([])
+  })
+})
+
+describe('runSummary', () => {
+  it('counts models, started entries and fusions', () => {
+    expect(runSummary(multiRun({ entries: [entry(), entry({ id: 2, status: 'failed' })], fusions: [fusion()] }))).toBe(
+      '2 models · 1 started · 1 fusions',
+    )
+  })
+})
+
+describe('parseLaunchForm', () => {
+  it('builds the launch request and defaults the name to the first prompt line', () => {
+    expect(parseLaunchForm(launchForm({ prompt: '  fix the flaky test\nmore detail', baseRef: ' main ' }), 1)).toEqual({
+      ok: true,
+      value: {
+        repoId: 1,
+        name: 'fix the flaky test',
+        prompt: 'fix the flaky test\nmore detail',
+        models: ['openai/gpt-5'],
+        isolate: true,
+        baseRef: 'main',
+      },
+    })
+  })
+
+  it('keeps an explicit name and drops the base ref for a shared directory', () => {
+    const result = parseLaunchForm(launchForm({ name: ' Sweep ', isolate: false, baseRef: 'main' }), 1)
+    expect(result).toEqual({
+      ok: true,
+      value: { repoId: 1, name: 'Sweep', prompt: 'fix the flaky test', models: ['openai/gpt-5'], isolate: false },
+    })
+  })
+
+  it('rejects a missing prompt or model and too many models', () => {
+    expect(parseLaunchForm(launchForm({ prompt: ' ' }), 1)).toEqual({ ok: false, error: 'Enter a prompt to send to every model.' })
+    expect(parseLaunchForm(launchForm({ models: [] }), 1)).toEqual({ ok: false, error: 'Choose at least one model.' })
+    expect(parseLaunchForm(launchForm({ models: ['a/1', 'a/2', 'a/3', 'a/4', 'a/5', 'a/6'] }), 1)).toEqual({
+      ok: false,
+      error: 'Choose at most 5 models.',
+    })
+  })
+})
+
+describe('toggleFusionSource', () => {
+  const run = multiRun({
+    entries: [
+      entry({ id: 1 }),
+      entry({ id: 2, sessionId: 'ses_2' }),
+      entry({ id: 3, status: 'failed', sessionId: null }),
+      entry({ id: 4, sessionId: 'ses_4' }),
+      entry({ id: 5, sessionId: 'ses_5' }),
+      entry({ id: 6, sessionId: 'ses_6' }),
+    ],
+  })
+
+  it('adds and removes started entries', () => {
+    expect(toggleFusionSource(run, [], 2)).toEqual([2])
+    expect(toggleFusionSource(run, [1, 2], 1)).toEqual([2])
+  })
+
+  it('keeps the selection in run order regardless of toggle order', () => {
+    expect(toggleFusionSource(run, [4], 1)).toEqual([1, 4])
+    expect(toggleFusionSource(run, [5, 2], 4)).toEqual([2, 4, 5])
+  })
+
+  it('ignores entries that are not started and selections past the model limit', () => {
+    expect(toggleFusionSource(run, [], 3)).toEqual([])
+    expect(toggleFusionSource(run, [1, 2, 4, 5, 6], 99)).toEqual([1, 2, 4, 5, 6])
+  })
+})
+
+describe('parseFusionForm', () => {
+  it('builds the fusion request without an isolate field and omits blank optional fields', () => {
+    expect(parseFusionForm({ entryIds: [1, 2], model: 'anthropic/claude', baseRef: ' ', instructions: ' ' }, UUID)).toEqual({
+      ok: true,
+      value: { requestId: UUID, entryIds: [1, 2], model: 'anthropic/claude' },
+    })
+    expect(
+      parseFusionForm({ entryIds: [1, 2], model: 'anthropic/claude', baseRef: 'main', instructions: ' keep tests ' }, UUID),
+    ).toEqual({
+      ok: true,
+      value: { requestId: UUID, entryIds: [1, 2], model: 'anthropic/claude', baseRef: 'main', instructions: 'keep tests' },
+    })
+  })
+
+  it('rejects fewer than two sources or a missing model', () => {
+    expect(parseFusionForm({ entryIds: [1], model: 'a/b', baseRef: '', instructions: '' }, UUID)).toEqual({
+      ok: false,
+      error: 'Select at least 2 started results to fuse.',
+    })
+    expect(parseFusionForm({ entryIds: [1, 2], model: '', baseRef: '', instructions: '' }, UUID)).toEqual({
+      ok: false,
+      error: 'Choose a synthesis model.',
+    })
+  })
+})
+
+describe('describeMultiRunError', () => {
+  it('reports an outdated Manager when the route is missing', () => {
+    expect(describeMultiRunError(new ManagerApiError('not found', 404, null, 'list multi-runs'))).toEqual({
+      message: MULTI_RUN_ROUTE_MISSING,
+    })
+  })
+
+  it('lists each unavailable fusion source', () => {
+    const error = new ManagerApiError('conflict', 409, 'Some selected results are not ready to fuse', 'fuse multi-run', {
+      unavailableSources: [
+        { entryId: 1, model: 'openai/gpt-5', reason: 'running', message: 'still running' },
+        { entryId: 2, model: 'anthropic/claude', reason: 'failed', message: 'failed' },
+      ],
+    })
+    expect(describeMultiRunError(error)).toEqual({ message: 'openai/gpt-5: still running\nanthropic/claude: failed' })
+  })
+
+  it('returns the session of a recovered fusion attempt', () => {
+    const error = new ManagerApiError('conflict', 409, 'An earlier fusion attempt is already running', 'fuse multi-run', {
+      fusions: [{ fusionId: 4, sessionId: 'ses_recovered' }],
+    })
+    expect(describeMultiRunError(error)).toEqual({
+      message: 'An earlier fusion attempt is already running.',
+      recoveredSessionId: 'ses_recovered',
+    })
+  })
+
+  it('falls back to the error message', () => {
+    expect(describeMultiRunError(new ManagerApiError('launch failed (500)', 500, 'boom', 'launch multi-run'))).toEqual({
+      message: 'launch failed (500)',
+    })
+    expect(describeMultiRunError(new Error('offline'))).toEqual({ message: 'offline' })
+  })
+})
+
+describe('runMultiRunCommand', () => {
+  it('refuses when not attached to a Manager repo', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const withoutRemote = { ...depsFor(api), remote: undefined }
+    const withoutRepo = { ...depsFor(api), remote: { ...remote, repoId: undefined } }
+
+    await runMultiRunCommand(fake.context, withoutRemote, '/multirun fix it')
+    await runMultiRunCommand(fake.context, withoutRepo)
+
+    expect(fake.toast).toHaveBeenCalledTimes(2)
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'error', message: MULTI_RUN_ATTACH_REQUIRED })
+    expect(withoutRemote.showLaunchDialog).not.toHaveBeenCalled()
+    expect(withoutRepo.showRunsDialog).not.toHaveBeenCalled()
+  })
+
+  it('reports an auth failure without opening a dialog', async () => {
+    vi.mocked(resolveManagerAuth).mockResolvedValue({ ok: false, message: 'No token stored.' })
+    const fake = createFakeContext()
+    const deps = depsFor(makeApi())
+
+    await runMultiRunCommand(fake.context, deps)
+
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'error', message: 'No token stored.' })
+    expect(deps.showRunsDialog).not.toHaveBeenCalled()
+  })
+
+  it('opens the launch dialog prefilled with the slash argument', async () => {
+    const fake = createFakeContext()
+    const deps = depsFor(makeApi())
+
+    await runMultiRunCommand(fake.context, deps, '/multirun  fix the flaky test ')
+
+    expect(deps.showLaunchDialog).toHaveBeenCalledWith({ actions: expect.any(Object), initialPrompt: 'fix the flaky test' })
+    expect(deps.showRunsDialog).not.toHaveBeenCalled()
+  })
+
+  it('opens the runs dialog without a prompt, whose new action opens an empty launch dialog', async () => {
+    const fake = createFakeContext()
+    const deps = depsFor(makeApi())
+
+    await runMultiRunCommand(fake.context, deps, '/multirun')
+    deps.showRunsDialog.mock.calls[0]![0].newRun()
+
+    expect(deps.showLaunchDialog).toHaveBeenCalledWith({ actions: expect.any(Object), initialPrompt: '' })
+  })
+})
+
+describe('multi-run dialog actions', () => {
+  it('launches, toasts the result, and opens the started sessions', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.launchMultiRun.mockResolvedValue(
+      multiRun({ name: 'fix the flaky test', entries: [entry({ id: 1, sessionId: 'ses_1' }), entry({ id: 2, sessionId: 'ses_2' })] }),
+    )
+    const actions = await launchActions(fake, api)
+
+    await expect(actions.launch(launchForm())).resolves.toBeNull()
+
+    expect(api.launchMultiRun).toHaveBeenCalledWith({
+      repoId: 1,
+      name: 'fix the flaky test',
+      prompt: 'fix the flaky test',
+      models: ['openai/gpt-5'],
+      isolate: true,
+    })
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'success', message: 'Launched fix the flaky test: 2/2 started' })
+    expect(fake.open).toHaveBeenCalledWith('ses_1')
+    expect(fake.open).toHaveBeenCalledWith('ses_2')
+  })
+
+  it('warns about failed entries after a launch', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.launchMultiRun.mockResolvedValue(
+      multiRun({ entries: [entry(), entry({ id: 2, model: 'anthropic/claude', status: 'failed', sessionId: null, error: 'quota' })] }),
+    )
+    const actions = await launchActions(fake, api)
+
+    await actions.launch(launchForm())
+
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'warning', message: 'Launched sweep: 1/2 started\nanthropic/claude: quota' })
+  })
+
+  it('returns validation and API errors from launch without toasting', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.launchMultiRun.mockRejectedValue(new ManagerApiError('not found', 404, null, 'launch multi-run'))
+    const actions = await launchActions(fake, api)
+
+    await expect(actions.launch(launchForm({ models: [] }))).resolves.toBe('Choose at least one model.')
+    await expect(actions.launch(launchForm())).resolves.toBe(MULTI_RUN_ROUTE_MISSING)
+    expect(fake.toast).not.toHaveBeenCalled()
+  })
+
+  it('lists runs for the attached repo', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.listMultiRuns.mockResolvedValue([multiRun()])
+    const actions = await launchActions(fake, api)
+
+    await expect(actions.list()).resolves.toEqual({ ok: true, value: [multiRun()] })
+    expect(api.listMultiRuns).toHaveBeenCalledWith(1)
+  })
+
+  it('discards an entry and returns the updated run', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    const updated = multiRun({ entries: [entry({ status: 'discarded' })] })
+    api.discardMultiRunEntry.mockResolvedValue(updated)
+    const actions = await launchActions(fake, api)
+
+    await expect(actions.discard(multiRun(), entry())).resolves.toEqual({ ok: true, value: updated })
+    expect(api.discardMultiRunEntry).toHaveBeenCalledWith(3, 1)
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'success', message: 'Discarded openai/gpt-5' })
+  })
+
+  it('fuses with a fresh request id and opens the fusion session', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.fuseMultiRun.mockImplementation(async (_runId: number, request: { requestId: string }) =>
+      multiRun({ fusions: [fusion({ requestId: request.requestId, sessionId: 'ses_f' })] }),
+    )
+    const actions = await launchActions(fake, api)
+
+    await expect(
+      actions.fuse(multiRun(), { entryIds: [1, 2], model: 'anthropic/claude', baseRef: '', instructions: '' }),
+    ).resolves.toBeNull()
+
+    const request = api.fuseMultiRun.mock.calls[0]![1] as Record<string, unknown>
+    expect(request).toEqual({ requestId: expect.stringMatching(/^[0-9a-f-]{36}$/), entryIds: [1, 2], model: 'anthropic/claude' })
+    expect(request).not.toHaveProperty('isolate')
+    expect(fake.open).toHaveBeenCalledWith('ses_f')
+  })
+
+  it('reports a failed fusion', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.fuseMultiRun.mockImplementation(async (_runId: number, request: { requestId: string }) =>
+      multiRun({ fusions: [fusion({ requestId: request.requestId, status: 'failed', sessionId: null, error: 'context limit' })] }),
+    )
+    const actions = await launchActions(fake, api)
+
+    await expect(
+      actions.fuse(multiRun(), { entryIds: [1, 2], model: 'anthropic/claude', baseRef: '', instructions: '' }),
+    ).resolves.toBe('context limit')
+    expect(fake.open).not.toHaveBeenCalled()
+  })
+
+  it('opens the recovered fusion session instead of failing', async () => {
+    const fake = createFakeContext()
+    const api = makeApi()
+    api.fuseMultiRun.mockRejectedValue(
+      new ManagerApiError('conflict', 409, 'An earlier fusion attempt is already running', 'fuse multi-run', {
+        fusions: [{ fusionId: 4, sessionId: 'ses_recovered' }],
+      }),
+    )
+    const actions = await launchActions(fake, api)
+
+    await expect(
+      actions.fuse(multiRun(), { entryIds: [1, 2], model: 'anthropic/claude', baseRef: '', instructions: '' }),
+    ).resolves.toBeNull()
+    expect(fake.open).toHaveBeenCalledWith('ses_recovered')
+    expect(fake.toast).toHaveBeenCalledWith({
+      variant: 'info',
+      message: 'An earlier fusion attempt is already running. Opened it instead.',
+    })
+  })
+})
diff --git a/ocm-cli/test/tui-ocm.test.ts b/ocm-cli/test/tui-ocm.test.ts
new file mode 100644
index 000000000..27d8cfd67
--- /dev/null
+++ b/ocm-cli/test/tui-ocm.test.ts
@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { Context } from '@opencode/plugin/tui/context'
+import { runOcmSwitch } from '../src/tui-ocm.js'
+import type { ManagerRepo } from '../src/manager-repos.js'
+import type { RemoteContext } from '../src/remote-context.js'
+
+const mocks = vi.hoisted(() => ({
+  resolveManagerAuth: vi.fn(),
+  fetchRepos: vi.fn(),
+  resolveOpenCodeProjectId: vi.fn(),
+  warmRepoProxy: vi.fn(),
+  readState: vi.fn(),
+  writeState: vi.fn(),
+  setPendingWarp: vi.fn(),
+}))
+
+vi.mock('../src/manager-auth.js', () => ({ resolveManagerAuth: mocks.resolveManagerAuth }))
+vi.mock('../src/manager-repos.js', () => ({ fetchRepos: mocks.fetchRepos }))
+vi.mock('@opencode-manager/shared/project-id', () => ({ resolveOpenCodeProjectId: mocks.resolveOpenCodeProjectId }))
+vi.mock('../src/repo-proxy.js', () => ({ warmRepoProxy: mocks.warmRepoProxy }))
+vi.mock('../src/state.js', () => ({ readState: mocks.readState, writeState: mocks.writeState }))
+vi.mock('../src/warp.js', () => ({ setPendingWarp: mocks.setPendingWarp }))
+
+const MANAGER_URL = 'https://manager.example'
+
+function repo(overrides: Partial<ManagerRepo> = {}): ManagerRepo {
+  return {
+    repoId: 1,
+    name: 'oc-manager',
+    branch: 'main',
+    cloneStatus: 'ready',
+    directory: '/srv/repos/oc-manager',
+    projectId: 'proj_a',
+    isWorktree: false,
+    extra: { repoId: 1, localPath: 'oc-manager', fullPath: '/srv/repos/oc-manager' },
+    ...overrides,
+  }
+}
+
+function createFakeContext(route: { type: string; sessionID?: string } = { type: 'home' }) {
+  const toast = vi.fn()
+  const confirm = vi.fn()
+  const select = vi.fn()
+  const dispatch = vi.fn()
+  const context = {
+    ui: {
+      toast: { show: toast },
+      dialog: { confirm, select },
+      router: { current: () => route },
+    },
+    data: { session: { get: () => ({ location: { directory: '/work/session-dir' } }) } },
+    keymap: { dispatch },
+  } as unknown as Context
+  return { context, toast, confirm, select, dispatch }
+}
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.resolveManagerAuth.mockResolvedValue({ ok: true, managerUrl: MANAGER_URL, token: 'tok' })
+  mocks.readState.mockReturnValue({ managerUrl: MANAGER_URL })
+  mocks.resolveOpenCodeProjectId.mockResolvedValue('proj_a')
+})
+
+describe('runOcmSwitch from a local TUI', () => {
+  it('confirms and attaches to the single Manager repo matching this directory', async () => {
+    const fake = createFakeContext()
+    const match = repo()
+    mocks.fetchRepos.mockResolvedValue([match, repo({ repoId: 2, name: 'other', projectId: 'proj_b' })])
+    fake.confirm.mockResolvedValue(true)
+
+    await runOcmSwitch(fake.context, { remote: undefined, cwd: '/work/oc-manager' })
+
+    expect(mocks.resolveManagerAuth).toHaveBeenCalledWith(undefined)
+    expect(mocks.resolveOpenCodeProjectId).toHaveBeenCalledWith('/work/oc-manager')
+    expect(fake.confirm).toHaveBeenCalledWith(
+      expect.objectContaining({ title: 'Switch to OpenCode Manager', message: expect.stringContaining('attach to oc-manager on manager.example') }),
+    )
+    expect(mocks.warmRepoProxy).toHaveBeenCalledWith(MANAGER_URL, 'tok', 1)
+    expect(mocks.writeState).toHaveBeenCalledWith({
+      managerUrl: MANAGER_URL,
+      lastRepoId: 1,
+      lastRepoName: 'oc-manager',
+      lastRepoDir: '/srv/repos/oc-manager',
+      lastRepoBranch: 'main',
+    })
+    expect(mocks.setPendingWarp).toHaveBeenCalledWith({
+      kind: 'attach',
+      target: { managerUrl: MANAGER_URL, token: 'tok', repoId: 1, repoName: 'oc-manager' },
+    })
+    expect(fake.dispatch).toHaveBeenCalledWith('app.exit')
+    expect(mocks.warmRepoProxy.mock.invocationCallOrder[0]).toBeLessThan(fake.dispatch.mock.invocationCallOrder[0]!)
+  })
+
+  it('stays put when the switch is declined', async () => {
+    const fake = createFakeContext()
+    mocks.fetchRepos.mockResolvedValue([repo()])
+    fake.confirm.mockResolvedValue(false)
+
+    await runOcmSwitch(fake.context, { remote: undefined, cwd: '/work/oc-manager' })
+
+    expect(mocks.setPendingWarp).not.toHaveBeenCalled()
+    expect(fake.dispatch).not.toHaveBeenCalled()
+  })
+
+  it('uses the current session directory to find the matching repo', async () => {
+    const fake = createFakeContext({ type: 'session', sessionID: 'ses_a' })
+    mocks.fetchRepos.mockResolvedValue([repo()])
+
+    await runOcmSwitch(fake.context, { remote: undefined })
+
+    expect(mocks.resolveOpenCodeProjectId).toHaveBeenCalledWith('/work/session-dir')
+  })
+
+  it('offers a picker with matching repos first when several match, skipping repos that are not ready', async () => {
+    const fake = createFakeContext()
+    const main = repo()
+    const worktree = repo({ repoId: 3, name: 'oc-manager-feature', branch: 'feature', isWorktree: true })
+    const other = repo({ repoId: 2, name: 'other', projectId: 'proj_b', branch: null })
+    mocks.fetchRepos.mockResolvedValue([other, main, worktree, repo({ repoId: 4, name: 'cloning', cloneStatus: 'cloning' })])
+    fake.select.mockResolvedValue({ kind: 'repo', repo: worktree })
+
+    await runOcmSwitch(fake.context, { remote: undefined, cwd: '/work/oc-manager' })
+
+    const options = fake.select.mock.calls[0]![0].options as { title: string; description?: string; category: string }[]
+    expect(options.map((option) => [option.title, option.category, option.description])).toEqual([
+      ['oc-manager', 'Matches this directory', 'main'],
+      ['oc-manager-feature', 'Matches this directory', 'worktree · feature'],
+      ['other', 'Manager repos', undefined],
+    ])
+    expect(mocks.setPendingWarp).toHaveBeenCalledWith({
+      kind: 'attach',
+      target: { managerUrl: MANAGER_URL, token: 'tok', repoId: 3, repoName: 'oc-manager-feature' },
+    })
+  })
+
+  it('offers every ready repo when nothing matches, and does nothing when dismissed', async () => {
+    const fake = createFakeContext()
+    mocks.resolveOpenCodeProjectId.mockResolvedValue(null)
+    mocks.fetchRepos.mockResolvedValue([repo(), repo({ repoId: 2, name: 'other' })])
+    fake.select.mockResolvedValue(undefined)
+
+    await runOcmSwitch(fake.context, { remote: undefined, cwd: '/tmp' })
+
+    const options = fake.select.mock.calls[0]![0].options as { category: string }[]
+    expect(options.map((option) => option.category)).toEqual(['Manager repos', 'Manager repos'])
+    expect(mocks.warmRepoProxy).not.toHaveBeenCalled()
+    expect(mocks.setPendingWarp).not.toHaveBeenCalled()
+  })
+
+  it('reports a Manager without ready repos', async () => {
+    const fake = createFakeContext()
+    mocks.fetchRepos.mockResolvedValue([repo({ cloneStatus: 'error' })])
+
+    await runOcmSwitch(fake.context, { remote: undefined, cwd: '/work/oc-manager' })
+
+    expect(fake.toast).toHaveBeenCalledWith({
+      variant: 'error',
+      message: 'The Manager has no ready repos. Run `ocm push --create` first.',
+    })
+    expect(fake.select).not.toHaveBeenCalled()
+  })
+})
+
+describe('runOcmSwitch from an attached TUI', () => {
+  const remote: RemoteContext = { managerUrl: MANAGER_URL, managerHost: 'manager.example', repoName: 'oc-manager', repoId: 1 }
+
+  it('offers local opencode first and marks the current repo as unavailable', async () => {
+    const fake = createFakeContext()
+    mocks.fetchRepos.mockResolvedValue([repo(), repo({ repoId: 2, name: 'other' })])
+    fake.select.mockResolvedValue({ kind: 'local' })
+
+    await runOcmSwitch(fake.context, { remote })
+
+    expect(mocks.resolveManagerAuth).toHaveBeenCalledWith(MANAGER_URL)
+    expect(mocks.resolveOpenCodeProjectId).not.toHaveBeenCalled()
+    const options = fake.select.mock.calls[0]![0].options as { title: string; disabled?: boolean; description?: string }[]
+    expect(options.map((option) => [option.title, option.disabled ?? false])).toEqual([
+      ['Local opencode', false],
+      ['oc-manager', true],
+      ['other', false],
+    ])
+    expect(options[1]!.description).toBe('Current')
+    expect(mocks.setPendingWarp).toHaveBeenCalledWith({ kind: 'local' })
+    expect(mocks.warmRepoProxy).not.toHaveBeenCalled()
+    expect(fake.dispatch).toHaveBeenCalledWith('app.exit')
+  })
+
+  it('switches to another Manager repo', async () => {
+    const fake = createFakeContext()
+    const other = repo({ repoId: 2, name: 'other' })
+    mocks.fetchRepos.mockResolvedValue([repo(), other])
+    fake.select.mockResolvedValue({ kind: 'repo', repo: other })
+
+    await runOcmSwitch(fake.context, { remote })
+
+    expect(mocks.setPendingWarp).toHaveBeenCalledWith({
+      kind: 'attach',
+      target: { managerUrl: MANAGER_URL, token: 'tok', repoId: 2, repoName: 'other' },
+    })
+  })
+})
+
+describe('runOcmSwitch failures', () => {
+  it('reports an auth failure without contacting the Manager', async () => {
+    const fake = createFakeContext()
+    mocks.resolveManagerAuth.mockResolvedValue({ ok: false, message: 'No manager configured. Run `ocm login <url>` first.' })
+
+    await runOcmSwitch(fake.context, { remote: undefined })
+
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'error', message: 'No manager configured. Run `ocm login <url>` first.' })
+    expect(mocks.fetchRepos).not.toHaveBeenCalled()
+  })
+
+  it('reports a Manager request failure and does not exit', async () => {
+    const fake = createFakeContext()
+    mocks.fetchRepos.mockRejectedValue(new Error('manager responded 502 Bad Gateway'))
+
+    await runOcmSwitch(fake.context, { remote: undefined, cwd: '/work/oc-manager' })
+
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'error', message: 'manager responded 502 Bad Gateway' })
+    expect(fake.dispatch).not.toHaveBeenCalled()
+  })
+
+  it('does not exit when the repo proxy cannot be warmed', async () => {
+    const fake = createFakeContext()
+    mocks.fetchRepos.mockResolvedValue([repo()])
+    fake.confirm.mockResolvedValue(true)
+    mocks.warmRepoProxy.mockRejectedValue(new Error('Manager is older than ocm requires'))
+
+    await runOcmSwitch(fake.context, { remote: undefined, cwd: '/work/oc-manager' })
+
+    expect(fake.toast).toHaveBeenCalledWith({ variant: 'error', message: 'Manager is older than ocm requires' })
+    expect(mocks.setPendingWarp).not.toHaveBeenCalled()
+    expect(fake.dispatch).not.toHaveBeenCalled()
+  })
+})
diff --git a/ocm-cli/test/tui-plugin.test.ts b/ocm-cli/test/tui-plugin.test.ts
index 1af83f7a0..ea5c40330 100644
--- a/ocm-cli/test/tui-plugin.test.ts
+++ b/ocm-cli/test/tui-plugin.test.ts
@@ -74,8 +74,11 @@ vi.mock('../src/manager-api.js', () => ({
       super(message)
     }
   },
+  isManagerRouteMissing: vi.fn(() => false),
 }))
 
+const noFeatures = { remote: undefined, goals: undefined, dialogs: { goal: vi.fn(), multiRunLaunch: vi.fn(), multiRuns: vi.fn() } }
+
 const matched = { repoId: 1, name: 'repo', projectId: 'proj_1', branch: 'main' }
 const repos = [
   {
@@ -187,7 +190,7 @@ function configureMove(fake: ReturnType<typeof createFakeContext>) {
 }
 
 async function invokeMove(fake: ReturnType<typeof createFakeContext>) {
-  await setupOcm(fake.context, vi.fn())
+  await setupOcm(fake.context, vi.fn(), noFeatures)
   renderAppSlot(fake)
   const factory = fake.layer.mock.calls[0]![0] as () => { commands: { id: string; run: () => Promise<void> }[] }
   const command = factory().commands.find((entry) => entry.id === 'ocm.session.move')!
@@ -203,7 +206,7 @@ describe('setupOcm', () => {
   it('registers commands from the app slot so the host keymap provider is mounted', async () => {
     const fake = createFakeContext()
 
-    await setupOcm(fake.context, vi.fn())
+    await setupOcm(fake.context, vi.fn(), noFeatures)
 
     expect(fake.layer).not.toHaveBeenCalled()
     expect(fake.slot).toHaveBeenCalledWith(expect.objectContaining({ append: 'app' }))
@@ -214,6 +217,45 @@ describe('setupOcm', () => {
     const factory = fake.layer.mock.calls[0]![0] as () => { mode?: string }
     expect(factory().mode).toBe('global')
   })
+
+  it('exposes the goal slash command', async () => {
+    const fake = createFakeContext()
+
+    await setupOcm(fake.context, vi.fn(), noFeatures)
+    renderAppSlot(fake)
+
+    const factory = fake.layer.mock.calls[0]![0] as () => {
+      commands: { id: string; slash?: { name: string; arguments?: true } }[]
+    }
+    const goal = factory().commands.find((entry) => entry.id === 'ocm.goal')
+    expect(goal?.slash).toEqual({ name: 'goal', arguments: true })
+  })
+
+  it('exposes the multi-run slash command', async () => {
+    const fake = createFakeContext()
+
+    await setupOcm(fake.context, vi.fn(), noFeatures)
+    renderAppSlot(fake)
+
+    const factory = fake.layer.mock.calls[0]![0] as () => {
+      commands: { id: string; slash?: { name: string; arguments?: true } }[]
+    }
+    const multiRun = factory().commands.find((entry) => entry.id === 'ocm.multirun')
+    expect(multiRun?.slash).toEqual({ name: 'multirun', arguments: true })
+  })
+
+  it('exposes the server switch slash command', async () => {
+    const fake = createFakeContext()
+
+    await setupOcm(fake.context, vi.fn(), noFeatures)
+    renderAppSlot(fake)
+
+    const factory = fake.layer.mock.calls[0]![0] as () => {
+      commands: { id: string; slash?: { name: string; arguments?: true } }[]
+    }
+    const command = factory().commands.find((entry) => entry.id === 'ocm.switch')
+    expect(command?.slash).toEqual({ name: 'ocm' })
+  })
 })
 
 describe('ocm.session.move command', () => {
diff --git a/ocm-cli/test/warp.test.ts b/ocm-cli/test/warp.test.ts
index deb8d771d..8de30322a 100644
--- a/ocm-cli/test/warp.test.ts
+++ b/ocm-cli/test/warp.test.ts
@@ -1,9 +1,9 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
-import type { WarpTarget } from '../src/warp.js'
-import { setPendingWarp, takePendingWarp, buildAttachInvocation, runPendingWarp } from '../src/warp.js'
-import { REMOTE_MANAGER_URL_ENV, REMOTE_REPO_NAME_ENV } from '../src/remote-context.js'
+import type { AttachTarget, PendingWarp } from '../src/warp.js'
+import { setPendingWarp, takePendingWarp, buildAttachInvocation, buildLocalInvocation, runPendingWarp } from '../src/warp.js'
+import { REMOTE_MANAGER_URL_ENV, REMOTE_REPO_ID_ENV, REMOTE_REPO_NAME_ENV } from '../src/remote-context.js'
 
-const sampleTarget: WarpTarget = {
+const sampleTarget: AttachTarget = {
   managerUrl: 'https://manager.example.com',
   token: 'tok_abc123',
   repoId: 42,
@@ -11,6 +11,8 @@ const sampleTarget: WarpTarget = {
   repoName: 'my-repo',
 }
 
+const sampleWarp: PendingWarp = { kind: 'attach', target: sampleTarget }
+
 describe('buildAttachInvocation', () => {
   it('produces the server args and attach env for a target without a session', () => {
     const invocation = buildAttachInvocation({ managerUrl: 'https://manager.example.com', token: 'tok_abc123', repoId: 42, repoName: 'my-repo' })
@@ -24,6 +26,7 @@ describe('buildAttachInvocation', () => {
       OPENCODE_PASSWORD: 'tok_abc123',
       [REMOTE_MANAGER_URL_ENV]: 'https://manager.example.com',
       [REMOTE_REPO_NAME_ENV]: 'my-repo',
+      [REMOTE_REPO_ID_ENV]: '42',
     })
   })
 
@@ -39,18 +42,32 @@ describe('buildAttachInvocation', () => {
   })
 })
 
+describe('buildLocalInvocation', () => {
+  it('launches plain opencode without any Manager attach variables', () => {
+    const invocation = buildLocalInvocation({
+      PATH: '/usr/bin',
+      OPENCODE_PASSWORD: 'tok',
+      [REMOTE_MANAGER_URL_ENV]: 'https://manager.example.com',
+      [REMOTE_REPO_NAME_ENV]: 'my-repo',
+      [REMOTE_REPO_ID_ENV]: '42',
+    })
+
+    expect(invocation).toEqual({ args: [], env: { PATH: '/usr/bin' } })
+  })
+})
+
 describe('setPendingWarp / takePendingWarp', () => {
   beforeEach(() => {
     takePendingWarp()
   })
 
   it('round-trips the target', () => {
-    setPendingWarp(sampleTarget)
-    expect(takePendingWarp()).toEqual(sampleTarget)
+    setPendingWarp(sampleWarp)
+    expect(takePendingWarp()).toEqual(sampleWarp)
   })
 
   it('returns undefined on second take', () => {
-    setPendingWarp(sampleTarget)
+    setPendingWarp(sampleWarp)
     takePendingWarp()
     expect(takePendingWarp()).toBeUndefined()
   })
@@ -69,7 +86,7 @@ describe('runPendingWarp', () => {
 
   it('calls spawn once with the correct args and env', () => {
     const spawn = vi.fn()
-    setPendingWarp(sampleTarget)
+    setPendingWarp(sampleWarp)
     const invocation = buildAttachInvocation(sampleTarget)
 
     runPendingWarp(spawn)
@@ -85,9 +102,18 @@ describe('runPendingWarp', () => {
     )
   })
 
+  it('spawns a local opencode for a local warp', () => {
+    const spawn = vi.fn()
+    setPendingWarp({ kind: 'local' })
+
+    runPendingWarp(spawn)
+
+    expect(spawn).toHaveBeenCalledWith('opencode', [], { stdio: 'inherit', env: buildLocalInvocation().env })
+  })
+
   it('does not spawn again on a second invocation', () => {
     const spawn = vi.fn()
-    setPendingWarp(sampleTarget)
+    setPendingWarp(sampleWarp)
 
     runPendingWarp(spawn)
     runPendingWarp(spawn)
@@ -97,7 +123,7 @@ describe('runPendingWarp', () => {
 
   it('swallows a throwing spawn without propagating', () => {
     const spawn = vi.fn(() => { throw new Error('spawn failed') })
-    setPendingWarp(sampleTarget)
+    setPendingWarp(sampleWarp)
 
     expect(() => runPendingWarp(spawn)).not.toThrow()
     expect(spawn).toHaveBeenCalledOnce()
diff --git a/shared/src/notifications/format.ts b/shared/src/notifications/format.ts
index f6403a289..b097172f7 100644
--- a/shared/src/notifications/format.ts
+++ b/shared/src/notifications/format.ts
@@ -1,4 +1,4 @@
-import type { SessionGoalStatus, SessionGoalStopReason } from '../schemas/session-goals'
+import type { SessionGoal, SessionGoalStatus, SessionGoalStopReason } from '../schemas/session-goals'
 
 const GOAL_OUTCOME_TITLES: Record<SessionGoalStatus, string> = {
   active: 'Goal active',
@@ -27,6 +27,15 @@ export function getGoalStopReasonLabel(stopReason: SessionGoalStopReason): strin
   return GOAL_STOP_REASON_LABELS[stopReason]
 }
 
+export function getGoalTurnLabel(goal: Pick<SessionGoal, 'continuationCount' | 'maxContinuations'>): string {
+  return `Turn ${goal.continuationCount}/${goal.maxContinuations}`
+}
+
+export function getGoalTokenLabel(goal: Pick<SessionGoal, 'tokensUsed' | 'tokenBudget'>): string | null {
+  if (goal.tokenBudget === null) return null
+  return `${goal.tokensUsed.toLocaleString()}/${goal.tokenBudget.toLocaleString()} tokens`
+}
+
 const PERMISSION_LABELS: Record<string, string> = {
   read: 'Read File',
   edit: 'Edit File',