@swarmclawai/swarmclaw 1.5.48 → 1.5.49

package/src/lib/server/missions/mission-scheduler.ts

@@ -0,0 +1,107 @@
+import { log } from '@/lib/server/logger'
+import { hmrSingleton } from '@/lib/shared-utils'
+import { createNotification } from '@/lib/server/create-notification'
+import type { Mission } from '@/types'
+import {
+  listMissions,
+  patchMission,
+  saveMissionReport,
+} from './mission-repository'
+import { buildMissionReport } from './mission-report-builder'
+import { markBudgetExhausted } from './mission-service'
+
+const TAG = 'mission-scheduler'
+
+interface SchedulerState {
+  lastTickAt: number
+  inFlight: boolean
+}
+
+const state = hmrSingleton<SchedulerState>('mission_scheduler_state', () => ({
+  lastTickAt: 0,
+  inFlight: false,
+}))
+
+function dispatchInAppReport(mission: Mission, title: string, message: string): void {
+  try {
+    createNotification({
+      type: 'info',
+      title,
+      message,
+      entityType: 'mission',
+      entityId: mission.id,
+      actionLabel: 'Open mission',
+      actionUrl: `/missions/${mission.id}`,
+      dedupKey: `mission-report:${mission.id}:${Date.now()}`,
+    })
+  } catch (error) {
+    log.warn(TAG, `Failed to emit notification for mission ${mission.id}`, error)
+  }
+}
+
+function generateReportForMission(mission: Mission, isFinal: boolean, reason?: string): void {
+  try {
+    const from = mission.reportSchedule?.lastReportAt
+      ?? mission.usage.startedAt
+      ?? mission.createdAt
+    const to = Date.now()
+    const { report, deliveryMessage, deliveryTitle } = buildMissionReport(mission, { from, to }, {
+      isFinal,
+      windowSource: isFinal ? 'final' : 'schedule',
+    })
+    saveMissionReport(report)
+    dispatchInAppReport(mission, deliveryTitle, reason ?? deliveryMessage)
+    if (!isFinal && mission.reportSchedule) {
+      patchMission(mission.id, (current) => {
+        if (!current || !current.reportSchedule) return current
+        return {
+          ...current,
+          reportSchedule: { ...current.reportSchedule, lastReportAt: to },
+        }
+      })
+    }
+  } catch (error) {
+    log.error(TAG, `Failed to generate report for mission ${mission.id}`, error)
+  }
+}
+
+export function runMissionScheduler(): void {
+  if (state.inFlight) return
+  state.inFlight = true
+  try {
+    const now = Date.now()
+    state.lastTickAt = now
+    const missions = listMissions()
+    for (const mission of missions) {
+      if (mission.status !== 'running') continue
+
+      // Wallclock budget enforcement (scheduler is the authority for time-based exhaustion)
+      const startedAt = mission.usage.startedAt
+      if (mission.budget.maxWallclockSec != null && startedAt != null) {
+        const elapsedSec = (now - startedAt) / 1000
+        if (elapsedSec >= mission.budget.maxWallclockSec) {
+          const reason = `Wallclock budget exceeded (${Math.round(elapsedSec)}s)`
+          markBudgetExhausted(mission.id, reason)
+          // Reload the mission to pick up the new status before generating the final report.
+          const updated = listMissions().find((m) => m.id === mission.id)
+          if (updated) generateReportForMission(updated, true, reason)
+          continue
+        }
+      }
+
+      // Report schedule
+      const schedule = mission.reportSchedule
+      if (!schedule || !schedule.enabled) continue
+      const lastAt = schedule.lastReportAt ?? startedAt ?? mission.createdAt
+      const intervalMs = Math.max(30, schedule.intervalSec) * 1000
+      if (now - lastAt < intervalMs) continue
+      generateReportForMission(mission, false)
+    }
+  } finally {
+    state.inFlight = false
+  }
+}
+
+export function getSchedulerLastTickAt(): number {
+  return state.lastTickAt
+}

package/src/lib/server/missions/mission-service.test.ts

@@ -0,0 +1,201 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+import type { Mission } from '@/types'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let service: typeof import('./mission-service')
+let hook: typeof import('./mission-budget-hook')
+let repo: typeof import('./mission-repository')
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-mission-svc-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  service = await import('./mission-service')
+  hook = await import('./mission-budget-hook')
+  repo = await import('./mission-repository')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+function createDraft(sessionId: string, overrides: Partial<Parameters<typeof service.createMission>[0]> = {}): Mission {
+  return service.createMission({
+    title: 'Smoke',
+    goal: 'Do the thing',
+    rootSessionId: sessionId,
+    agentIds: ['a1'],
+    ...overrides,
+  })
+}
+
+describe('mission-service: lifecycle', () => {
+  it('creates a draft mission with zeroed usage', () => {
+    const m = createDraft('svc_s_1')
+    assert.equal(m.status, 'draft')
+    assert.equal(m.usage.usdSpent, 0)
+    assert.equal(m.usage.turnsRun, 0)
+    assert.equal(m.usage.startedAt, null)
+    assert.deepEqual(m.budget.warnAtFractions, [0.5, 0.8, 0.95])
+  })
+
+  it('startMission transitions draft to running, sets startedAt, records milestone', () => {
+    const m = createDraft('svc_s_2')
+    const started = service.startMission(m.id)
+    assert.equal(started?.status, 'running')
+    assert.ok((started?.usage.startedAt ?? 0) > 0)
+    assert.equal(started?.milestones[0]?.kind, 'started')
+  })
+
+  it('pauseMission transitions running to paused', () => {
+    const m = createDraft('svc_s_3')
+    service.startMission(m.id)
+    const paused = service.pauseMission(m.id, 'checking in')
+    assert.equal(paused?.status, 'paused')
+  })
+
+  it('cancelMission records endReason and stops', () => {
+    const m = createDraft('svc_s_4')
+    service.startMission(m.id)
+    const cancelled = service.cancelMission(m.id, 'user stop')
+    assert.equal(cancelled?.status, 'cancelled')
+    assert.equal(cancelled?.endReason, 'user stop')
+    assert.ok((cancelled?.endedAt ?? 0) > 0)
+  })
+
+  it('completeMission transitions to completed', () => {
+    const m = createDraft('svc_s_5')
+    service.startMission(m.id)
+    const done = service.completeMission(m.id, 'goal met')
+    assert.equal(done?.status, 'completed')
+  })
+})
+
+describe('mission-service: budget evaluation', () => {
+  it('allows when under all caps', () => {
+    const m = createDraft('svc_b_1', { budget: { maxUsd: 1, maxTokens: 1000, maxTurns: 5 } })
+    const started = service.startMission(m.id)!
+    const verdict = service.evaluateMissionBudget(started)
+    assert.equal(verdict.allow, true)
+  })
+
+  it('denies when USD cap is hit', () => {
+    const m = createDraft('svc_b_2', { budget: { maxUsd: 0.1 } })
+    service.startMission(m.id)
+    service.recordTurnUsage(m.id, { usdDelta: 0.15, turnsDelta: 1 })
+    const latest = repo.getMission(m.id)!
+    const verdict = service.evaluateMissionBudget(latest)
+    assert.equal(verdict.allow, false)
+    assert.equal(verdict.hitCap, 'usd')
+  })
+
+  it('denies when max turns is reached', () => {
+    const m = createDraft('svc_b_3', { budget: { maxTurns: 2 } })
+    service.startMission(m.id)
+    service.recordTurnUsage(m.id, { turnsDelta: 2 })
+    const latest = repo.getMission(m.id)!
+    const verdict = service.evaluateMissionBudget(latest)
+    assert.equal(verdict.allow, false)
+    assert.equal(verdict.hitCap, 'turns')
+  })
+
+  it('denies when wallclock budget is exceeded', () => {
+    const m = createDraft('svc_b_4', { budget: { maxWallclockSec: 60 } })
+    service.startMission(m.id)
+    const now = Date.now()
+    const fakeFuture = now + 61_000
+    const latest = repo.getMission(m.id)!
+    const verdict = service.evaluateMissionBudget(latest, fakeFuture)
+    assert.equal(verdict.allow, false)
+    assert.equal(verdict.hitCap, 'wallclock')
+  })
+
+  it('fires a budget_warn milestone at the crossed threshold', () => {
+    const m = createDraft('svc_b_5', { budget: { maxTurns: 10, warnAtFractions: [0.5] } })
+    service.startMission(m.id)
+    service.recordTurnUsage(m.id, { turnsDelta: 5 })
+    const latest = repo.getMission(m.id)!
+    assert.ok(latest.usage.warnFractionsHit.includes(0.5))
+    const warn = latest.milestones.find((ms) => ms.kind === 'budget_warn')
+    assert.ok(warn, 'expected a budget_warn milestone')
+  })
+
+  it('does not fire the same warn threshold twice', () => {
+    const m = createDraft('svc_b_6', { budget: { maxTurns: 10, warnAtFractions: [0.5] } })
+    service.startMission(m.id)
+    service.recordTurnUsage(m.id, { turnsDelta: 5 })
+    service.recordTurnUsage(m.id, { turnsDelta: 1 })
+    const latest = repo.getMission(m.id)!
+    const warnCount = latest.milestones.filter((ms) => ms.kind === 'budget_warn').length
+    assert.equal(warnCount, 1)
+  })
+})
+
+describe('mission-budget-hook', () => {
+  it('allows when missionId is null', () => {
+    const verdict = hook.checkMissionBudgetForSession(null)
+    assert.equal(verdict.allow, true)
+  })
+
+  it('allows when mission does not exist', () => {
+    const verdict = hook.checkMissionBudgetForSession('does-not-exist')
+    assert.equal(verdict.allow, true)
+  })
+
+  it('denies when mission is in draft status', () => {
+    const m = createDraft('svc_h_1')
+    const verdict = hook.checkMissionBudgetForSession(m.id)
+    assert.equal(verdict.allow, false)
+  })
+
+  it('allows when mission is running and under budget', () => {
+    const m = createDraft('svc_h_2', { budget: { maxTurns: 10 } })
+    service.startMission(m.id)
+    const verdict = hook.checkMissionBudgetForSession(m.id)
+    assert.equal(verdict.allow, true)
+  })
+
+  it('transitions mission to budget_exhausted when cap is hit', () => {
+    const m = createDraft('svc_h_3', { budget: { maxTurns: 1 } })
+    service.startMission(m.id)
+    service.recordTurnUsage(m.id, { turnsDelta: 1 })
+    const verdict = hook.checkMissionBudgetForSession(m.id)
+    assert.equal(verdict.allow, false)
+    const latest = repo.getMission(m.id)!
+    assert.equal(latest.status, 'budget_exhausted')
+    assert.ok(latest.endedAt)
+  })
+
+  it('session-to-mission map tracks running mission', () => {
+    const m = createDraft('svc_map_1')
+    service.startMission(m.id)
+    const resolved = service.getMissionIdForSession('svc_map_1')
+    assert.equal(resolved, m.id)
+  })
+
+  it('session-to-mission map clears after mission ends', () => {
+    const m = createDraft('svc_map_2')
+    service.startMission(m.id)
+    service.completeMission(m.id)
+    const resolved = service.getMissionIdForSession('svc_map_2')
+    assert.equal(resolved, null)
+  })
+})

package/src/lib/server/missions/mission-service.ts

@@ -0,0 +1,299 @@
+import crypto from 'crypto'
+import type { Mission, MissionBudget, MissionReportSchedule, MissionStatus } from '@/types'
+import { DEFAULT_MISSION_WARN_FRACTIONS } from '@/types'
+import { hmrSingleton } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+import {
+  appendMissionEvent,
+  appendMissionMilestone,
+  getMission,
+  listMissions,
+  patchMission,
+  upsertMission,
+} from './mission-repository'
+
+const TAG = 'mission-service'
+
+interface MissionRuntimeCache {
+  sessionToMission: Map<string, string>
+  hydratedAt: number
+}
+
+const runtime = hmrSingleton<MissionRuntimeCache>('mission_runtime_state', () => ({
+  sessionToMission: new Map(),
+  hydratedAt: 0,
+}))
+
+function hydrateSessionMap(force = false): void {
+  const now = Date.now()
+  if (!force && now - runtime.hydratedAt < 30_000) return
+  const missions = listMissions()
+  const next = new Map<string, string>()
+  for (const m of missions) {
+    if (m.status === 'running' || m.status === 'paused') {
+      if (m.rootSessionId) next.set(m.rootSessionId, m.id)
+    }
+  }
+  runtime.sessionToMission = next
+  runtime.hydratedAt = now
+}
+
+export function getMissionIdForSession(sessionId: string): string | null {
+  if (!sessionId) return null
+  hydrateSessionMap(false)
+  return runtime.sessionToMission.get(sessionId) ?? null
+}
+
+export function trackSessionMissionMapping(sessionId: string, missionId: string | null): void {
+  if (!sessionId) return
+  if (missionId) runtime.sessionToMission.set(sessionId, missionId)
+  else runtime.sessionToMission.delete(sessionId)
+}
+
+export interface CreateMissionInput {
+  title: string
+  goal: string
+  successCriteria?: string[]
+  rootSessionId: string
+  agentIds?: string[]
+  budget?: Partial<MissionBudget>
+  reportSchedule?: MissionReportSchedule | null
+  reportConnectorIds?: string[]
+}
+
+function newMissionId(): string {
+  return `mi_${crypto.randomBytes(8).toString('hex')}`
+}
+
+function sanitizeBudget(input: Partial<MissionBudget> = {}): MissionBudget {
+  const pick = (v: unknown): number | null => (typeof v === 'number' && Number.isFinite(v) ? v : null)
+  const warn = Array.isArray(input.warnAtFractions) && input.warnAtFractions.length
+    ? input.warnAtFractions.filter((f) => typeof f === 'number' && f > 0 && f < 1)
+    : DEFAULT_MISSION_WARN_FRACTIONS
+  return {
+    maxUsd: pick(input.maxUsd),
+    maxTokens: pick(input.maxTokens),
+    maxToolCalls: pick(input.maxToolCalls),
+    maxWallclockSec: pick(input.maxWallclockSec),
+    maxTurns: pick(input.maxTurns),
+    warnAtFractions: warn.length ? warn : DEFAULT_MISSION_WARN_FRACTIONS,
+  }
+}
+
+export function createMission(input: CreateMissionInput): Mission {
+  const now = Date.now()
+  const mission: Mission = {
+    id: newMissionId(),
+    title: input.title.trim(),
+    goal: input.goal.trim(),
+    successCriteria: (input.successCriteria ?? []).map((s) => s.trim()).filter(Boolean),
+    rootSessionId: input.rootSessionId,
+    agentIds: input.agentIds ?? [],
+    status: 'draft',
+    budget: sanitizeBudget(input.budget),
+    usage: {
+      usdSpent: 0,
+      tokensUsed: 0,
+      toolCallsUsed: 0,
+      turnsRun: 0,
+      wallclockMsElapsed: 0,
+      startedAt: null,
+      lastUpdatedAt: now,
+      warnFractionsHit: [],
+    },
+    milestones: [],
+    reportSchedule: input.reportSchedule ?? null,
+    reportConnectorIds: input.reportConnectorIds ?? [],
+    createdAt: now,
+    updatedAt: now,
+  }
+  upsertMission(mission)
+  log.info(TAG, `Created mission ${mission.id} (goal: ${mission.goal.slice(0, 80)})`)
+  return mission
+}
+
+function applyStatusTransition(
+  id: string,
+  next: MissionStatus,
+  opts: { reason?: string; milestoneSummary?: string; endReason?: string } = {},
+): Mission | null {
+  const updated = patchMission(id, (current) => {
+    if (!current) return null
+    const patch: Mission = { ...current, status: next }
+    if (next === 'running' && !current.usage.startedAt) {
+      patch.usage = { ...current.usage, startedAt: Date.now(), lastUpdatedAt: Date.now() }
+      patch.startedAt = patch.startedAt ?? Date.now()
+    }
+    if (next === 'completed' || next === 'failed' || next === 'cancelled' || next === 'budget_exhausted') {
+      patch.endedAt = Date.now()
+      patch.endReason = opts.endReason ?? opts.reason ?? null
+    }
+    return patch
+  })
+  if (!updated) return null
+  if (opts.milestoneSummary) {
+    appendMissionMilestone(id, {
+      kind: mapStatusToMilestoneKind(next),
+      summary: opts.milestoneSummary,
+    })
+  }
+  trackSessionMissionMapping(
+    updated.rootSessionId,
+    next === 'running' || next === 'paused' ? id : null,
+  )
+  return getMission(id)
+}
+
+function mapStatusToMilestoneKind(
+  status: MissionStatus,
+): 'started' | 'paused' | 'resumed' | 'completed' | 'failed' | 'cancelled' | 'budget_hit' {
+  switch (status) {
+    case 'running': return 'started'
+    case 'paused': return 'paused'
+    case 'completed': return 'completed'
+    case 'failed': return 'failed'
+    case 'cancelled': return 'cancelled'
+    case 'budget_exhausted': return 'budget_hit'
+    default: return 'started'
+  }
+}
+
+export function startMission(id: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'running') return current
+  const next = current.status === 'paused' ? 'running' : 'running'
+  const summary = current.status === 'paused' ? 'Mission resumed' : 'Mission started'
+  const updated = applyStatusTransition(id, next, { milestoneSummary: summary })
+  if (updated && current.status === 'paused') {
+    appendMissionMilestone(id, { kind: 'resumed', summary: 'Mission resumed' })
+  }
+  return updated
+}
+
+export function pauseMission(id: string, reason?: string): Mission | null {
+  const current = getMission(id)
+  if (!current || current.status !== 'running') return current
+  return applyStatusTransition(id, 'paused', {
+    reason,
+    milestoneSummary: reason ?? 'Mission paused',
+  })
+}
+
+export function cancelMission(id: string, reason?: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'completed' || current.status === 'cancelled') return current
+  return applyStatusTransition(id, 'cancelled', {
+    endReason: reason,
+    milestoneSummary: reason ?? 'Mission cancelled',
+  })
+}
+
+export function completeMission(id: string, summary?: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'completed') return current
+  return applyStatusTransition(id, 'completed', {
+    endReason: summary,
+    milestoneSummary: summary ?? 'Mission complete',
+  })
+}
+
+export function failMission(id: string, reason: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'failed') return current
+  return applyStatusTransition(id, 'failed', {
+    endReason: reason,
+    milestoneSummary: reason,
+  })
+}
+
+export function markBudgetExhausted(id: string, reason: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'budget_exhausted' || current.status === 'completed') return current
+  appendMissionEvent(id, 'budget_exhausted', { reason })
+  return applyStatusTransition(id, 'budget_exhausted', {
+    endReason: reason,
+    milestoneSummary: reason,
+  })
+}
+
+export interface BudgetVerdict {
+  allow: boolean
+  reason?: string
+  hitCap?: 'usd' | 'tokens' | 'toolCalls' | 'wallclock' | 'turns'
+  warningFraction?: number
+}
+
+export function evaluateMissionBudget(mission: Mission, at: number = Date.now()): BudgetVerdict {
+  const { budget, usage } = mission
+  if (budget.maxUsd != null && usage.usdSpent >= budget.maxUsd) {
+    return { allow: false, hitCap: 'usd', reason: `USD budget exhausted (${usage.usdSpent.toFixed(4)} >= ${budget.maxUsd})` }
+  }
+  if (budget.maxTokens != null && usage.tokensUsed >= budget.maxTokens) {
+    return { allow: false, hitCap: 'tokens', reason: `Token budget exhausted (${usage.tokensUsed} >= ${budget.maxTokens})` }
+  }
+  if (budget.maxToolCalls != null && usage.toolCallsUsed >= budget.maxToolCalls) {
+    return { allow: false, hitCap: 'toolCalls', reason: `Tool-call budget exhausted (${usage.toolCallsUsed} >= ${budget.maxToolCalls})` }
+  }
+  if (budget.maxTurns != null && usage.turnsRun >= budget.maxTurns) {
+    return { allow: false, hitCap: 'turns', reason: `Max turns reached (${usage.turnsRun} >= ${budget.maxTurns})` }
+  }
+  if (budget.maxWallclockSec != null && usage.startedAt != null) {
+    const elapsedSec = (at - usage.startedAt) / 1000
+    if (elapsedSec >= budget.maxWallclockSec) {
+      return { allow: false, hitCap: 'wallclock', reason: `Wallclock budget exhausted (${Math.round(elapsedSec)}s >= ${budget.maxWallclockSec}s)` }
+    }
+  }
+  // Warn thresholds, highest unfired fraction first
+  const unfired = (budget.warnAtFractions ?? [])
+    .filter((f) => !usage.warnFractionsHit.includes(f))
+    .sort((a, b) => b - a)
+  for (const fraction of unfired) {
+    const tripped = (
+      (budget.maxUsd != null && usage.usdSpent >= budget.maxUsd * fraction)
+      || (budget.maxTokens != null && usage.tokensUsed >= budget.maxTokens * fraction)
+      || (budget.maxTurns != null && usage.turnsRun >= budget.maxTurns * fraction)
+      || (
+        budget.maxWallclockSec != null && usage.startedAt != null
+        && (at - usage.startedAt) / 1000 >= budget.maxWallclockSec * fraction
+      )
+    )
+    if (tripped) return { allow: true, warningFraction: fraction }
+  }
+  return { allow: true }
+}
+
+export function recordTurnUsage(
+  missionId: string,
+  delta: { usdDelta?: number; tokensDelta?: number; toolCallsDelta?: number; turnsDelta?: number },
+): Mission | null {
+  let firedWarn: number | null = null
+  const result = patchMission(missionId, (current) => {
+    if (!current) return null
+    const now = Date.now()
+    const nextUsage = { ...current.usage }
+    if (typeof delta.usdDelta === 'number' && Number.isFinite(delta.usdDelta)) nextUsage.usdSpent += delta.usdDelta
+    if (typeof delta.tokensDelta === 'number' && Number.isFinite(delta.tokensDelta)) nextUsage.tokensUsed += delta.tokensDelta
+    if (typeof delta.toolCallsDelta === 'number' && Number.isFinite(delta.toolCallsDelta)) nextUsage.toolCallsUsed += delta.toolCallsDelta
+    if (typeof delta.turnsDelta === 'number' && Number.isFinite(delta.turnsDelta)) nextUsage.turnsRun += delta.turnsDelta
+    if (nextUsage.startedAt) nextUsage.wallclockMsElapsed = now - nextUsage.startedAt
+    nextUsage.lastUpdatedAt = now
+    const verdict = evaluateMissionBudget({ ...current, usage: nextUsage }, now)
+    if (verdict.warningFraction != null) {
+      firedWarn = verdict.warningFraction
+      nextUsage.warnFractionsHit = [...nextUsage.warnFractionsHit, verdict.warningFraction]
+    }
+    return { ...current, usage: nextUsage }
+  })
+  if (result && firedWarn != null) {
+    appendMissionMilestone(missionId, {
+      kind: 'budget_warn',
+      summary: `Budget ${Math.round(firedWarn * 100)}% reached`,
+    })
+  }
+  return result
+}

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

@@ -31,6 +31,7 @@ import { logExecution } from '@/lib/server/execution-log'
 import { createNotification } from '@/lib/server/create-notification'
 import { WORKER_ONLY_PROVIDER_IDS } from '@/lib/provider-sets'
 import { buildSwarmFeedHeartbeatGuidance } from '@/lib/server/swarmfeed-runtime'
+import { runMissionScheduler } from '@/lib/server/missions/mission-scheduler'
 
 const HEARTBEAT_TICK_MS = 60_000
 const MAX_CONCURRENT_HEARTBEATS = 1
@@ -576,6 +577,10 @@ export async function tickHeartbeats() {
   const globalOngoing = shouldRunHeartbeats(settings)
 
   const now = Date.now()
+  // Mission scheduler runs every tick, independent of heartbeat active window,
+  // so wallclock budgets and periodic reports still fire overnight.
+  try { runMissionScheduler() } catch (error) { log.warn('heartbeat', 'mission scheduler tick failed', error) }
+
   const nowDate = new Date(now)
   if (!inActiveWindow(nowDate, settings.heartbeatActiveStart, settings.heartbeatActiveEnd, settings.heartbeatTimezone)) {
     return

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

@@ -8,6 +8,7 @@ import { getEnabledToolIds } from '@/lib/capability-selection'
 import { isAllEstopEngaged, isAutonomyEstopEngaged } from '@/lib/server/runtime/estop'
 import { isRestartRecoverableSource } from '@/lib/server/runtime/run-ledger'
 import { getActiveSessionProcess } from '@/lib/server/runtime/runtime-state'
+import { checkMissionBudgetForSession } from '@/lib/server/missions/mission-budget-hook'
 
 import { cancelPendingForSession } from './cancellation'
 import {
@@ -49,6 +50,7 @@ const LONG_TOOL_NAMES: ReadonlySet<string> = new Set(['claude_code', 'codex_cli'
 type SessionToolConfig = {
   tools?: string[] | null
   extensions?: string[] | null
+  missionId?: string | null
 }
 
 function computeEffectiveRunTimeoutMs(
@@ -114,6 +116,13 @@ export function enqueueSessionRun(
   if (isAutonomyEstopEngaged() && isAutonomyManagedEnqueue(source, internal)) {
     throw new Error(`Autonomy estop is engaged. New ${source} runs are paused.`)
   }
+  if (isAutonomyManagedEnqueue(source, internal)) {
+    const sessionForMission = getSession(input.sessionId) as SessionToolConfig | null
+    const missionVerdict = checkMissionBudgetForSession(sessionForMission?.missionId ?? null)
+    if (!missionVerdict.allow) {
+      throw new Error(`Mission halted: ${missionVerdict.reason ?? 'budget exhausted'}`)
+    }
+  }
   const executionKey = typeof input.executionGroupKey === 'string' && input.executionGroupKey.trim()
     ? input.executionGroupKey.trim()
     : executionKeyForSession(input.sessionId)