@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/lib/server/protocols/protocol-types.ts

@@ -6,7 +6,6 @@ import type {
   BoardTask,
   Chatroom,
   MessageToolEvent,
-  Mission,
   ProtocolBranchCase,
   ProtocolPhaseDefinition,
   ProtocolRepeatConfig,
@@ -31,7 +30,6 @@ export interface ProtocolRunDetail {
   template: ProtocolTemplate | null
   transcript: Chatroom | null
   parentChatroom: Chatroom | null
-  linkedMission: Mission | null
   linkedTask: BoardTask | null
   events: ProtocolRunEvent[]
 }

package/src/lib/server/provider-health.ts

@@ -42,7 +42,7 @@ function commandExists(binary: string): boolean {
   pruneTTLCache(cliCheckCache, CLI_CHECK_TTL_MS, CLI_CHECK_CACHE_MAX)
   const probe = isWindows
     ? spawnSync('where', [binary], { timeout: 2000, stdio: 'pipe' })
-    : spawnSync('/bin/zsh', ['-lc', `command -v ${binary} >/dev/null 2>&1`], { timeout: 2000 })
+    : spawnSync(process.env.SHELL || '/bin/bash', ['-lc', `command -v ${binary} >/dev/null 2>&1`], { timeout: 2000 })
   const ok = (probe.status ?? 1) === 0
   cliCheckCache.set(binary, { at: now, ok })
   return ok
@@ -92,15 +92,6 @@ export function markProviderSuccess(providerId: string, credentialId?: string |
     const { upsertStoredItem } = require('@/lib/server/storage')
     upsertStoredItem('provider_health', key, states.get(key)!)
   } catch {}
-  queueMicrotask(() => {
-    import('@/lib/server/missions/mission-service')
-      .then(({ requestMissionTicksForProviderRecovery }) => {
-        requestMissionTicksForProviderRecovery(providerId)
-      })
-      .catch(() => {
-        // Mission recovery is best-effort only.
-      })
-  })
 }
 
 export function isProviderCoolingDown(providerId: string, credentialId?: string | null): boolean {

package/src/lib/server/runtime/daemon-state/core.ts

@@ -66,7 +66,6 @@ import { loadEstopState } from '@/lib/server/runtime/estop'
 import { classifyRuntimeFailure, recordSupervisorIncident } from '@/lib/server/autonomy/supervisor-reflection'
 import { getMemoryDb } from '@/lib/server/memory/memory-db'
 import { clearLogsByAge } from '@/lib/server/execution-log'
-import { runMissionControllerStartupRecovery } from '@/lib/server/missions/mission-service'
 
 const TAG = 'daemon-state'
 
@@ -293,14 +292,6 @@ export function startDaemon(options?: { source?: string; manualStart?: boolean }
       if (lost > 0) log.info(TAG, `[daemon] Marked ${lost} in-flight swarm(s) as lost after restart`)
     } catch { /* best-effort */ }
     resumeQueue()
-    const missionRecovery = runMissionControllerStartupRecovery()
-    if (missionRecovery.recovered > 0 || missionRecovery.rerunVerification > 0) {
-      log.info(
-        TAG,
-        `[daemon] Recovered ${missionRecovery.recovered} mission(s) on startup`
-          + ` (${missionRecovery.rerunVerification} queued for verification replay)`,
-      )
-    }
     startScheduler()
     startQueueProcessor()
     startBrowserSweep()

package/src/lib/server/runtime/daemon-state.test.ts

@@ -245,41 +245,6 @@ describe('daemon start/stop lifecycle', () => {
     }
   })
 
-  it('startDaemon runs mission startup recovery once the daemon owns startup', async () => {
-    const storage = await import('@/lib/server/storage')
-    storage.saveMissions({
-      missionA: {
-        id: 'missionA',
-        source: 'chat',
-        sourceRef: { kind: 'chat', sessionId: 'sessionA' },
-        objective: 'Recover after daemon start',
-        status: 'active',
-        phase: 'executing',
-        sessionId: 'sessionA',
-        taskIds: [],
-        controllerState: {
-          activeRunId: 'run-stale',
-          currentTaskId: 'task-stale',
-        },
-        createdAt: 1,
-        updatedAt: 1,
-      },
-    })
-
-    await mod.stopDaemon({ source: 'test-prestart' })
-    mod.startDaemon({ source: 'test-mission-recovery', manualStart: true })
-    try {
-      const missions = await import('@/lib/server/missions/mission-service')
-      const mission = missions.loadMissionById('missionA')
-      assert.equal(mission?.status, 'active')
-      assert.equal(mission?.phase, 'planning')
-      const events = missions.listMissionEventsForMission('missionA')
-      assert.ok(events.some((event) => event.type === 'interrupted'))
-    } finally {
-      await mod.stopDaemon({ source: 'test-mission-recovery' })
-    }
-  })
-
   it('stopDaemon sets running to false', async () => {
     mod.startDaemon({ source: 'test', manualStart: true })
     await mod.stopDaemon({ source: 'test' })

package/src/lib/server/runtime/heartbeat-service.ts

@@ -10,17 +10,15 @@ import { logActivity } from '@/lib/server/activity/activity-log'
 import { loadApprovals } from '@/lib/server/approvals/approval-repository'
 import { loadAgents, patchAgent } from '@/lib/server/agents/agent-repository'
 import { loadChatrooms } from '@/lib/server/chatrooms/chatroom-repository'
-import { loadMission } from '@/lib/server/missions/mission-repository'
 import { loadSessions, patchSession } from '@/lib/server/sessions/session-repository'
 import { loadSettings } from '@/lib/server/settings/settings-repository'
-import { buildGoalAncestrySection, buildPlatformStatusSummary } from '@/lib/server/chat-execution/situational-awareness'
+import { buildPlatformStatusSummary } from '@/lib/server/chat-execution/situational-awareness'
 import { drainDeferredWakes, hasDeferredWakes } from '@/lib/server/runtime/wake-dispatcher'
 import { buildWakeTriggerContext } from '@/lib/server/runtime/heartbeat-wake'
 import { enqueueSessionRun, getSessionRunState } from '@/lib/server/runtime/session-run-manager'
 import { log } from '@/lib/server/logger'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { drainSystemEvents, drainOrchestratorEvents } from '@/lib/server/runtime/system-events'
-import { buildMissionContextBlock } from '@/lib/server/missions/mission-service'
 import { getMessages, getRecentMessages, clearMessages } from '@/lib/server/messages/message-repository'
 import type { Agent, AppSettings, ApprovalRequest, Chatroom, Message, Session } from '@/types'
 import { isOrchestratorEligible } from '@/lib/orchestrator-config'
@@ -357,12 +355,7 @@ export function buildAgentHeartbeatPrompt(
     }
   }
 
-  // ── Phase 3: Goal ancestry ──
-  const missionId = (session.missionId || (agent as Record<string, unknown>).missionId || null) as string | null
-  const goalAncestry = buildGoalAncestrySection(missionId)
-  if (goalAncestry) sections.push(goalAncestry)
-
-  // ── Phase 4: Active task checkout & events ──
+  // ── Phase 3: Active task checkout & events ──
   const events = drainSystemEvents(session.id!)
   if (events.length > 0) {
     const eventBlock = events.map((e) => `- [${new Date(e.timestamp).toISOString()}] ${e.text}`).join('\n')
@@ -983,20 +976,7 @@ export function buildOrchestratorWakePrompt(session: any, agent: Agent): string
     addSection(`## System Events\n${eventBlock}`)
   }
 
-  // 7. Active mission state
-  const missionId = session.missionId || null
-  if (missionId) {
-    try {
-      const missionBlock = buildMissionContextBlock(loadMission(missionId))
-      if (missionBlock) addSection(missionBlock)
-    } catch { /* ignore */ }
-  }
-
-  // 8. Goal ancestry
-  const goalAncestry = buildGoalAncestrySection(missionId)
-  if (goalAncestry) addSection(goalAncestry)
-
-  // 9. Chatroom membership
+  // 7. Chatroom membership
   try {
     const chatrooms = Object.values(loadChatrooms()) as Chatroom[]
     const myChatrooms = chatrooms.filter((c) => !c.archivedAt && c.agentIds?.includes(agent.id))

package/src/lib/server/runtime/process-manager.ts

@@ -1,5 +1,5 @@
 import { genId } from '@/lib/id'
-import { hmrSingleton, sleep } from '@/lib/shared-utils'
+import { hmrSingleton, sleep, errorMessage } from '@/lib/shared-utils'
 import { spawn, type ChildProcessWithoutNullStreams } from 'child_process'
 import { detectDocker } from '@/lib/server/sandbox/docker-detect'
 import { log } from '@/lib/server/logger'
@@ -169,7 +169,8 @@ export function buildDockerExecArgs(params: {
 
 export function getShellCommand(command: string, processId?: string, sandbox?: SandboxOptions): { shell: string; args: string[]; containerName?: string } {
   if (!sandbox) {
-    return { shell: '/bin/zsh', args: ['-lc', command] }
+    const shell = process.env.SHELL || '/bin/bash'
+    return { shell, args: ['-lc', command] }
   }
 
   if (sandbox.kind === 'persistent') {
@@ -247,9 +248,12 @@ export async function startManagedProcess(opts: StartProcessOptions): Promise<St
   state.records.set(id, record)
 
   const { shell, args } = getShellCommand(opts.command, id, opts.sandbox)
-  // Strip SwarmClaw-specific env vars so agent child processes don't inherit
-  // our port binding or internal keys (e.g. npm dev servers defaulting to :3456)
-  const stripKeys = new Set(['PORT', 'ACCESS_KEY', 'NEXTAUTH_SECRET'])
+  // Strip env vars that should not leak into child processes:
+  // - PORT, ACCESS_KEY, NEXTAUTH_SECRET: SwarmClaw-specific bindings
+  // - npm_config_prefix: injected by npm when running scripts; conflicts with nvm
+  //   in login shell subprocesses (nvm refuses to initialize when this is set,
+  //   breaking node PATH resolution for all nvm users)
+  const stripKeys = new Set(['PORT', 'ACCESS_KEY', 'NEXTAUTH_SECRET', 'npm_config_prefix'])
   const cleanEnv = Object.fromEntries(Object.entries(process.env).filter(([k]) => !stripKeys.has(k))) as NodeJS.ProcessEnv
   const child = spawn(shell, args, {
     cwd: opts.sandbox ? undefined : opts.cwd,
@@ -405,8 +409,8 @@ export function writeManagedProcessStdin(processId: string, data: string, eof?:
     if (data) child.stdin.write(data)
     if (eof) child.stdin.end()
     return { ok: true }
-  } catch (err: any) {
-    return { ok: false, error: err.message || String(err) }
+  } catch (err: unknown) {
+    return { ok: false, error: errorMessage(err) || String(err) }
   }
 }
 
@@ -418,8 +422,8 @@ export function killManagedProcess(processId: string, signal: NodeJS.Signals = '
     rec.status = 'killed'
     child.kill(signal)
     return { ok: true }
-  } catch (err: any) {
-    return { ok: false, error: err.message || String(err) }
+  } catch (err: unknown) {
+    return { ok: false, error: errorMessage(err) || String(err) }
   }
 }
 

package/src/lib/server/runtime/queue/core.ts

@@ -23,6 +23,7 @@ import type { ExecuteChatTurnResult } from '@/lib/server/chat-execution/chat-exe
 import { checkAgentBudgetLimits } from '@/lib/server/cost'
 import { enqueueExecution } from '@/lib/server/execution-engine'
 import { extractTaskResult, formatResultBody } from '@/lib/server/tasks/task-result'
+import { checkoutTask } from '@/lib/server/tasks/task-checkout'
 import {
   classifyRuntimeFailure,
   observeAutonomyRunOutcome,
@@ -51,7 +52,6 @@ import {
   markValidatedTaskCompleted,
   refreshTaskCompletionValidation,
 } from '@/lib/server/tasks/task-lifecycle'
-import { noteMissionTaskFinished, noteMissionTaskStarted } from '@/lib/server/missions/mission-service'
 
 const TAG = 'queue'
 
@@ -1210,25 +1210,16 @@ export async function processNext() {
         } catch {}
       }
 
-      const beforeStartTasks = loadTasks() as Record<string, BoardTask>
-      task = beforeStartTasks[taskId] as BoardTask | undefined
-      if (!task || task.status !== 'queued') {
-        return
-      }
-
-      // Mark as running
+      // Atomic checkout — prevents two runners from starting the same task
+      const runId = genId()
+      task = checkoutTask(taskId, runId) as BoardTask | undefined
+      if (!task) return
       applyTaskPolicyDefaults(task)
-      task.status = 'running'
-      task.startedAt = Date.now()
-      task.lastActivityAt = Date.now()
-      task.retryScheduledAt = null
-      task.deadLetteredAt = null
-      // Clear transient failure fields so validation/error state reflects only this attempt.
-      task.error = null
-      task.validation = null
-      task.updatedAt = Date.now()
       logActivity({ entityType: 'task', entityId: taskId, action: 'running', actor: 'system', actorId: task.agentId, summary: `Task started: "${task.title}"` })
 
+      // Reload tasks map for resolution functions and final save (checkoutTask already saved the running status)
+      const allTasks = loadTasks() as Record<string, BoardTask>
+      allTasks[taskId] = task
       const sessionsForCwd = loadSessions() as Record<string, SessionLike>
       const taskCwd = resolveTaskExecutionCwd(task as ScheduleTaskMeta, sessionsForCwd)
       task.cwd = taskCwd
@@ -1238,8 +1229,8 @@ export async function processNext() {
       const sourceScheduleId = typeof scheduleTask.sourceScheduleId === 'string'
         ? scheduleTask.sourceScheduleId
         : ''
-      const reusableTaskSessionId = resolveReusableTaskSessionId(task, beforeStartTasks, sessionsForCwd)
-      const resumeContext = resolveTaskResumeContext(task, beforeStartTasks, sessionsForCwd as Record<string, SessionLike | Session>)
+      const reusableTaskSessionId = resolveReusableTaskSessionId(task, allTasks, sessionsForCwd)
+      const resumeContext = resolveTaskResumeContext(task, allTasks, sessionsForCwd as Record<string, SessionLike | Session>)
 
       // Resolve the agent's persistent thread session to use as parentSessionId
       const agentThreadSessionId = agent.threadSessionId || null
@@ -1307,8 +1298,7 @@ export async function processNext() {
         note: `Attempt ${(task.attempts || 0) + 1}/${task.maxAttempts || '?'} started${continuationBits.length ? ` (${continuationBits.join('; ')})` : ''}`,
         updatedAt: Date.now(),
       }
-      saveTasks(beforeStartTasks)
-      noteMissionTaskStarted(task, task.id)
+      saveTasks(allTasks)
       pushMainLoopEventToMainSessions({
         type: 'task_running',
         text: `Task running: "${task.title}" (${task.id}) with ${agent.name}`,
@@ -1485,13 +1475,6 @@ export async function processNext() {
           disableSessionHeartbeat(t2[taskId].sessionId)
         }
         const doneTask = t2[taskId]
-        if (doneTask?.status === 'completed') {
-          noteMissionTaskFinished(doneTask, 'completed', taskRunId)
-        } else if (doneTask?.status === 'failed') {
-          noteMissionTaskFinished(doneTask, 'failed', taskRunId)
-        } else if (doneTask?.status === 'cancelled') {
-          noteMissionTaskFinished(doneTask, 'cancelled', taskRunId)
-        }
         queueTaskAutonomyObservation({
           runId: taskRunId,
           sessionId,
@@ -1636,11 +1619,6 @@ export async function processNext() {
             })
           }
           saveTasks(t3)
-          if (t3[taskId].status === 'failed') {
-            noteMissionTaskFinished(t3[taskId], 'failed', taskRunId)
-          } else if (t3[taskId].status === 'cancelled') {
-            noteMissionTaskFinished(t3[taskId], 'cancelled', taskRunId)
-          }
           notify('tasks')
           notify('runs')
           disableSessionHeartbeat(t3[taskId].sessionId)

package/src/lib/server/runtime/runtime-storage-write-paths.test.ts

@@ -9,7 +9,7 @@ function readRepoSource(relativePath: string): string {
   return fs.readFileSync(path.join(repoRoot, relativePath), 'utf-8')
 }
 
-test('runtime hot paths use row-level task, schedule, and agent writes', () => {
+test('runtime hot paths use row-level task, schedule, and wallet writes', () => {
   const expectations = [
     {
       file: 'src/lib/server/runtime/scheduler.ts',
@@ -17,14 +17,14 @@ test('runtime hot paths use row-level task, schedule, and agent writes', () => {
       forbidden: ['saveTasks(', 'saveSchedules('],
     },
     {
-      file: 'src/app/api/schedules/[id]/run/route.ts',
-      required: ['upsertTask(', 'upsertSchedule('],
+      file: 'src/lib/server/schedules/schedule-route-service.ts',
+      required: ['saveTask(', 'upsertSchedule('],
       forbidden: ['saveTasks(', 'saveSchedules('],
     },
     {
-      file: 'src/lib/server/wallet/wallet-service.ts',
-      required: ['loadAgent(', 'upsertAgent('],
-      forbidden: ['saveAgents('],
+      file: 'src/lib/server/wallets/wallet-service.ts',
+      required: ['saveWallet(', 'deleteWallet('],
+      forbidden: ['saveWallets('],
     },
   ] as const
 

package/src/lib/server/runtime/scheduler.ts

@@ -10,7 +10,6 @@ import { processDueWatchJobs } from '@/lib/server/runtime/watch-jobs'
 import { isAgentDisabled } from '@/lib/server/agents/agent-availability'
 import { prepareScheduledTaskRun } from '@/lib/server/tasks/task-lifecycle'
 import { ensureAgentThreadSession } from '@/lib/server/agents/agent-thread-session'
-import { ensureMissionForTask, noteScheduleMissionTriggered } from '@/lib/server/missions/mission-service'
 import { hasActiveProtocolRunForSchedule, launchProtocolRunForSchedule } from '@/lib/server/protocols/protocol-service'
 import { hmrSingleton } from '@/lib/shared-utils'
 import { log } from '@/lib/server/logger'
@@ -168,10 +167,6 @@ async function tick(now = Date.now()) {
       // Wake-only: no board task, just heartbeat the agent
       upsertSchedule(schedule.id, schedule)
       const wakeSessionId = resolveScheduleWakeSessionId(schedule, agents as Record<string, unknown>)
-      noteScheduleMissionTriggered(schedule, {
-        wakeOnly: true,
-        sessionId: wakeSessionId || schedule.createdInSessionId || null,
-      })
 
       const wakeMessage = schedule.message || `Schedule triggered: ${schedule.name}`
       pushMainLoopEventToMainSessions({
@@ -205,16 +200,8 @@ async function tick(now = Date.now()) {
         now,
         scheduleSignature,
       })
-      const mission = noteScheduleMissionTriggered(schedule, {
-        taskId,
-        sessionId: schedule.createdInSessionId || null,
-      })
-      if (mission) {
-        tasks[taskId].missionId = mission.id
-      }
 
       upsertTask(taskId, tasks[taskId])
-      ensureMissionForTask(tasks[taskId], { source: 'schedule' })
       upsertSchedule(schedule.id, schedule)
 
       enqueueTask(taskId)

package/src/lib/server/runtime/session-run-manager/drain.ts

@@ -90,7 +90,6 @@ export async function drainExecution(
     })
 
     let runtimeTimer: ReturnType<typeof setTimeout> | null = null
-    let finishedMissionId: string | null = null
     if (next.maxRuntimeMs && next.maxRuntimeMs > 0) {
       runtimeTimer = setTimeout(() => {
         next.signalController.abort()
@@ -119,8 +118,6 @@ export async function drainExecution(
       next.run.status = aborted ? 'cancelled' : (failed ? 'failed' : 'completed')
       next.run.endedAt = next.run.endedAt || now()
       next.run.error = aborted ? (next.run.error || 'Cancelled') : result.error
-      next.run.missionId = result.missionId || next.run.missionId || null
-      finishedMissionId = next.run.missionId || null
       next.run.resultPreview = result.text?.slice(0, 280)
       if (typeof result.inputTokens === 'number') next.run.totalInputTokens = result.inputTokens
       if (typeof result.outputTokens === 'number') next.run.totalOutputTokens = result.outputTokens
@@ -186,7 +183,6 @@ export async function drainExecution(
       next.run.status = aborted ? 'cancelled' : 'failed'
       next.run.endedAt = now()
       next.run.error = errorMessage(err)
-      finishedMissionId = next.run.missionId || null
       syncRunRecord(next.run)
       emitRunMeta(next, next.run.status, { error: next.run.error })
       log.error('session-run', `Run failed ${next.run.id}`, {
@@ -216,26 +212,6 @@ export async function drainExecution(
       decrementNonHeartbeatWork(next)
       reconcileSessionActivityLease(next.run.sessionId)
       notify(`stream-end:${next.run.sessionId}`)
-      if (finishedMissionId && next.run.source !== 'chat') {
-        const missionId = finishedMissionId
-        queueMicrotask(() => {
-          import('@/lib/server/missions/mission-service')
-            .then(({ loadMissionById, requestMissionTick }) => {
-              const mission = loadMissionById(missionId)
-              if (!mission) return
-              if (mission.status !== 'active') return
-              if (mission.phase === 'dispatching' || mission.phase === 'executing') return
-              requestMissionTick(missionId, 'run_drained', {
-                runId: next.run.id,
-                source: next.run.source,
-                status: next.run.status,
-              })
-            })
-            .catch((err: unknown) => {
-              log.warn('session-run', 'Mission tick failed', { missionId, runId: next.run.id, error: errorMessage(err) })
-            })
-        })
-      }
       void drainExecution(executionKey, deps)
     }
   } finally {

package/src/lib/server/runtime/session-run-manager/enqueue.ts

@@ -215,7 +215,6 @@ export function enqueueSessionRun(
   const run: SessionRunRecord = {
     id: runId,
     sessionId: input.sessionId,
-    missionId: input.missionId ?? getSession(input.sessionId)?.missionId ?? null,
     kind: 'session_turn',
     ownerType: 'session',
     ownerId: input.sessionId,

package/src/lib/server/runtime/session-run-manager/queries.ts

@@ -37,7 +37,6 @@ function toQueuedTurn(entry: SessionRunQueueEntry, index: number): SessionQueued
   return {
     runId: entry.run.id,
     sessionId: entry.run.sessionId,
-    missionId: entry.run.missionId || null,
     text: entry.message,
     queuedAt: entry.run.queuedAt,
     position: index + 1,
@@ -49,12 +48,27 @@ function toQueuedTurn(entry: SessionRunQueueEntry, index: number): SessionQueued
   }
 }
 
+function toActiveTurn(entry: SessionRunQueueEntry): SessionQueuedTurn {
+  return {
+    ...toQueuedTurn(entry, 0),
+    position: 0,
+  }
+}
+
+function visibleActiveTurnForSession(sessionId: string): SessionQueuedTurn | null {
+  const running = Array.from(state.runningByExecution.values())
+    .find((entry) => entry.run.sessionId === sessionId && entry.run.status === 'running')
+  if (!running || running.run.internal === true) return null
+  return toActiveTurn(running)
+}
+
 export function getSessionQueueSnapshot(sessionId: string): SessionQueueSnapshot {
   const execution = getSessionExecutionState(sessionId)
   const visibleQueued = visibleQueuedEntriesForSession(sessionId)
   return {
     sessionId,
     activeRunId: execution.runningRunId || null,
+    activeTurn: visibleActiveTurnForSession(sessionId),
     queueLength: visibleQueued.length,
     items: visibleQueued.map((entry, index) => toQueuedTurn(entry, index)),
   }

package/src/lib/server/runtime/session-run-manager/recovery.ts

@@ -48,7 +48,6 @@ function resolveRecoveredQueuedEntry(entry: SessionRunQueueEntry, reason: string
   entry.resolve({
     runId: entry.run.id,
     sessionId: entry.run.sessionId,
-    ...(entry.run.missionId ? { missionId: entry.run.missionId } : {}),
     text: '',
     persisted: false,
     toolEvents: [],

package/src/lib/server/runtime/session-run-manager.test.ts

@@ -249,34 +249,6 @@ describe('session-run-manager', () => {
       assert.ok(run.queuedAt > 0)
     })
 
-    it('copies the session mission id into queued run snapshots', () => {
-      storage.upsertSession('sess-mission', {
-        id: 'sess-mission',
-        cwd: process.cwd(),
-        user: 'tester',
-        provider: 'ollama',
-        model: 'test-model',
-        claudeSessionId: null,
-        messages: [],
-        createdAt: Date.now(),
-        lastActiveAt: Date.now(),
-        agentId: 'test-agent',
-        missionId: 'mission-123',
-      })
-      const release = mgr.acquireExternalSessionExecutionHold('sess-mission')
-
-      const result = enqueue({
-        sessionId: 'sess-mission',
-        message: 'Continue the release mission',
-      })
-
-      const run = mgr.getRunById(result.runId)
-      const snapshot = mgr.getSessionQueueSnapshot('sess-mission')
-      assert.equal(run?.missionId, 'mission-123')
-      assert.equal(snapshot.items[0]?.missionId, 'mission-123')
-      release()
-    })
-
     it('persists run records and replay events in storage', () => {
       const result = enqueue({
         sessionId: 'sess-persisted',
@@ -521,6 +493,37 @@ describe('session-run-manager', () => {
       })
     })
 
+    it('exposes the active user-visible turn separately from queued follow-ups', () => {
+      const running = enqueue({
+        sessionId: 'sess-active-turn',
+        message: 'running now',
+        source: 'chat',
+      })
+      const queued = enqueue({
+        sessionId: 'sess-active-turn',
+        message: 'queued next',
+        source: 'chat',
+      })
+
+      const snapshot = mgr.getSessionQueueSnapshot('sess-active-turn')
+      assert.equal(snapshot.activeRunId, running.runId)
+      assert.deepEqual(snapshot.activeTurn, {
+        runId: running.runId,
+        sessionId: 'sess-active-turn',
+        missionId: null,
+        text: 'running now',
+        queuedAt: snapshot.activeTurn?.queuedAt,
+        position: 0,
+        imagePath: undefined,
+        imageUrl: undefined,
+        attachedFiles: undefined,
+        replyToId: undefined,
+        source: 'chat',
+      })
+      assert.deepEqual(snapshot.items.map((item) => item.runId), [queued.runId])
+      assert.equal(snapshot.queueLength, 1)
+    })
+
     it('hides internal queued runs from the user-visible queue snapshot', () => {
       enqueue({ sessionId: 'sess-visible-queue', message: 'running' })
       enqueue({
@@ -538,9 +541,36 @@ describe('session-run-manager', () => {
 
       const snapshot = mgr.getSessionQueueSnapshot('sess-visible-queue')
       assert.equal(snapshot.queueLength, 1)
+      assert.equal(snapshot.activeTurn?.runId, snapshot.activeRunId)
       assert.deepEqual(snapshot.items.map((item) => item.runId), [visible.runId])
     })
 
+    it('hides internal active runs from the active-turn snapshot field', () => {
+      const { entry, promise } = makeManualQueuedEntry({
+        sessionId: 'sess-hidden-active',
+        runId: 'run-hidden',
+        message: 'heartbeat hidden',
+        internal: true,
+        source: 'heartbeat',
+      })
+      entry.run.status = 'running'
+      entry.run.startedAt = Date.now()
+      const state = getRuntimeState()
+      state.runningByExecution.set(entry.executionKey, entry as unknown)
+      state.runs.set(entry.run.id, entry.run)
+      state.promises.set(entry.run.id, promise)
+      pendingPromises.push(promise.catch(() => {}))
+
+      try {
+        const snapshot = mgr.getSessionQueueSnapshot('sess-hidden-active')
+        assert.equal(snapshot.activeRunId, 'run-hidden')
+        assert.equal(snapshot.activeTurn, null)
+        assert.equal(snapshot.queueLength, 0)
+      } finally {
+        entry.resolve(undefined)
+      }
+    })
+
     it('reports heartbeat vs non-heartbeat queued runs', () => {
       enqueue({ sessionId: 'sess-hb-state', message: 'occupier' })
       enqueue({

package/src/lib/server/sandbox/session-runtime.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
-import { resolveSandboxRuntimeStatus, resolveSandboxWorkdir } from '@/lib/server/sandbox/session-runtime'
+import { resolveSandboxRuntimeStatus, resolveSandboxSessionContext, resolveSandboxWorkdir } from '@/lib/server/sandbox/session-runtime'
 import type { Session } from '@/types'
 
 test('resolveSandboxRuntimeStatus defaults enabled sandboxes to all sessions', () => {
@@ -49,6 +49,23 @@ test('resolveSandboxRuntimeStatus sandboxes child sessions in non-main mode', ()
   assert.equal(status.scopeKey, 'agent:agent-1')
 })
 
+test('resolveSandboxSessionContext resolves browser-compatible workspace context without starting containers', () => {
+  const context = resolveSandboxSessionContext({
+    config: { enabled: true, scope: 'agent', workdir: '/workspace' },
+    session: {
+      id: 'child-session',
+      agentId: 'agent-1',
+      parentSessionId: 'main-session',
+    } as Session,
+    workspaceDir: '/tmp/project',
+  })
+
+  assert.ok(context)
+  assert.equal(context?.scopeKey, 'agent:agent-1')
+  assert.equal(context?.workspaceDir, '/tmp/project')
+  assert.equal(context?.containerWorkdir, '/workspace')
+})
+
 test('resolveSandboxWorkdir maps nested host paths into the container workspace', () => {
   const resolved = resolveSandboxWorkdir({
     workspaceDir: '/tmp/project',