@swarmclawai/swarmclaw 1.2.8 → 1.3.0

package/src/lib/server/goals/goal-service.ts

@@ -0,0 +1,143 @@
+import type { Goal, GoalLevel } from '@/types'
+import { genId } from '@/lib/id'
+import { listGoals, getGoal, saveGoal, removeGoal } from './goal-repository'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import { notify } from '@/lib/server/ws-hub'
+
+export function getAllGoals(): Goal[] {
+  return Object.values(listGoals())
+}
+
+export function getGoalById(id: string): Goal | null {
+  return getGoal(id)
+}
+
+export function createGoal(input: {
+  title: string
+  description?: string
+  level: GoalLevel
+  parentGoalId?: string | null
+  projectId?: string | null
+  agentId?: string | null
+  taskId?: string | null
+  objective: string
+  constraints?: string[]
+  successMetric?: string | null
+  budgetUsd?: number | null
+  deadlineAt?: number | null
+}): Goal {
+  const id = genId()
+  const now = Date.now()
+  const goal: Goal = {
+    id,
+    title: input.title,
+    description: input.description,
+    level: input.level,
+    parentGoalId: input.parentGoalId ?? null,
+    projectId: input.projectId ?? null,
+    agentId: input.agentId ?? null,
+    taskId: input.taskId ?? null,
+    objective: input.objective,
+    constraints: input.constraints ?? [],
+    successMetric: input.successMetric ?? null,
+    budgetUsd: input.budgetUsd ?? null,
+    deadlineAt: input.deadlineAt ?? null,
+    status: 'active',
+    createdAt: now,
+    updatedAt: now,
+  }
+  saveGoal(id, goal)
+  logActivity({ entityType: 'task', entityId: id, action: 'created', actor: 'user', summary: `Goal created: "${goal.title}" (${goal.level})` })
+  notify('goals')
+  return goal
+}
+
+export function updateGoal(id: string, updates: Partial<Omit<Goal, 'id' | 'createdAt'>>): Goal | null {
+  const existing = getGoal(id)
+  if (!existing) return null
+  const updated: Goal = {
+    ...existing,
+    ...updates,
+    id,
+    createdAt: existing.createdAt,
+    updatedAt: Date.now(),
+  }
+  saveGoal(id, updated)
+  logActivity({ entityType: 'task', entityId: id, action: 'updated', actor: 'user', summary: `Goal updated: "${updated.title}"` })
+  notify('goals')
+  return updated
+}
+
+export function deleteGoal(id: string): boolean {
+  const existing = getGoal(id)
+  if (!existing) return false
+  removeGoal(id)
+  logActivity({ entityType: 'task', entityId: id, action: 'deleted', actor: 'user', summary: `Goal deleted: "${existing.title}"` })
+  notify('goals')
+  return true
+}
+
+/**
+ * Walk the goal hierarchy to build a "why chain" from a specific goal up to the organization root.
+ * Returns goals in order from most specific to most general.
+ */
+export function getGoalChain(goalId: string): Goal[] {
+  const chain: Goal[] = []
+  const visited = new Set<string>()
+  let currentId: string | null | undefined = goalId
+  while (currentId && !visited.has(currentId)) {
+    visited.add(currentId)
+    const goal = getGoal(currentId)
+    if (!goal) break
+    chain.push(goal)
+    currentId = goal.parentGoalId
+  }
+  return chain
+}
+
+/**
+ * Resolve the effective goal for a given context by walking the hierarchy:
+ * task goal → agent goal → project goal → organization default.
+ */
+export function resolveEffectiveGoal(context: {
+  taskId?: string | null
+  agentId?: string | null
+  projectId?: string | null
+}): Goal | null {
+  const goals = getAllGoals().filter((g) => g.status === 'active')
+
+  // 1. Task-level goal
+  if (context.taskId) {
+    const taskGoal = goals.find((g) => g.taskId === context.taskId)
+    if (taskGoal) return taskGoal
+  }
+
+  // 2. Agent-level goal
+  if (context.agentId) {
+    const agentGoal = goals.find((g) => g.level === 'agent' && g.agentId === context.agentId)
+    if (agentGoal) return agentGoal
+  }
+
+  // 3. Project-level goal
+  if (context.projectId) {
+    const projectGoal = goals.find((g) => g.level === 'project' && g.projectId === context.projectId)
+    if (projectGoal) return projectGoal
+  }
+
+  // 4. Organization default
+  const orgGoal = goals.find((g) => g.level === 'organization')
+  return orgGoal ?? null
+}
+
+/**
+ * Format a goal chain as a concise text block for injection into agent execution briefs.
+ */
+export function formatGoalChainForBrief(chain: Goal[]): string {
+  if (chain.length === 0) return ''
+  const lines = chain.map((g, i) => {
+    const indent = '  '.repeat(i)
+    const label = g.level.charAt(0).toUpperCase() + g.level.slice(1)
+    return `${indent}${label}: ${g.title} — ${g.objective}`
+  })
+  return `Goal alignment:\n${lines.join('\n')}`
+}

package/src/lib/server/persistence/storage-context.ts

@@ -5,7 +5,6 @@ import { approvalRepository } from '@/lib/server/approvals/approval-repository'
 import { chatroomRepository } from '@/lib/server/chatrooms/chatroom-repository'
 import { connectorRepository } from '@/lib/server/connectors/connector-repository'
 import * as messageRepository from '@/lib/server/messages/message-repository'
-import { missionEventRepository, missionRepository } from '@/lib/server/missions/mission-repository'
 import { projectRepository } from '@/lib/server/projects/project-repository'
 import { scheduleRepository } from '@/lib/server/schedules/schedule-repository'
 import { sessionRepository } from '@/lib/server/sessions/session-repository'
@@ -19,8 +18,6 @@ export interface StorageTxContext {
   chatrooms: typeof chatroomRepository
   connectors: typeof connectorRepository
   messages: typeof messageRepository
-  missions: typeof missionRepository
-  missionEvents: typeof missionEventRepository
   projects: typeof projectRepository
   runs: typeof runRepository
   runEvents: typeof runEventRepository
@@ -37,8 +34,6 @@ export function createStorageTxContext(): StorageTxContext {
     chatrooms: chatroomRepository,
     connectors: connectorRepository,
     messages: messageRepository,
-    missions: missionRepository,
-    missionEvents: missionEventRepository,
     projects: projectRepository,
     runs: runRepository,
     runEvents: runEventRepository,

package/src/lib/server/portability/export.ts

@@ -0,0 +1,109 @@
+import { loadAgents } from '@/lib/server/agents/agent-repository'
+import { loadSkills } from '@/lib/server/skills/skill-repository'
+import { loadSchedules } from '@/lib/server/schedules/schedule-repository'
+import type { Agent } from '@/types/agent'
+import type { Skill } from '@/types/skill'
+import type { Schedule } from '@/types/schedule'
+
+export const PORTABILITY_FORMAT_VERSION = 1
+
+export interface PortableManifest {
+  formatVersion: number
+  exportedAt: string
+  agents: PortableAgent[]
+  skills: PortableSkill[]
+  schedules: PortableSchedule[]
+}
+
+export type PortableAgent = Omit<Agent,
+  // Strip runtime/sensitive fields
+  | 'id' | 'credentialId' | 'fallbackCredentialIds' | 'apiEndpoint'
+  | 'threadSessionId' | 'lastUsedAt' | 'totalCost' | 'trashedAt'
+  | 'openclawAgentId' | 'gatewayProfileId' | 'avatarUrl'
+> & {
+  /** Original ID — used for matching during import */
+  originalId: string
+}
+
+export type PortableSkill = Pick<Skill,
+  | 'name' | 'content' | 'description' | 'tags' | 'scope'
+  | 'author' | 'version' | 'primaryEnv' | 'capabilities'
+  | 'toolNames' | 'frontmatter'
+> & {
+  originalId: string
+}
+
+export type PortableSchedule = Pick<Schedule,
+  | 'name' | 'taskPrompt' | 'taskMode' | 'message' | 'description'
+  | 'scheduleType' | 'frequency' | 'cron' | 'atTime' | 'intervalMs'
+  | 'timezone' | 'action' | 'path' | 'command'
+> & {
+  originalId: string
+  /** Original agent ID — resolved to new ID during import */
+  originalAgentId: string
+}
+
+/** Sensitive fields stripped from exported agents */
+const AGENT_STRIP_KEYS: (keyof Agent)[] = [
+  'id', 'credentialId', 'fallbackCredentialIds', 'apiEndpoint',
+  'threadSessionId', 'lastUsedAt', 'totalCost', 'trashedAt',
+  'openclawAgentId', 'gatewayProfileId', 'avatarUrl',
+]
+
+export function exportConfig(): PortableManifest {
+  const agents = loadAgents()
+  const skills = loadSkills()
+  const schedules = loadSchedules()
+
+  const portableAgents: PortableAgent[] = Object.values(agents)
+    .filter((a) => !a.trashedAt && !a.disabled)
+    .map((agent) => {
+      const portable = { ...agent, originalId: agent.id } as Record<string, unknown>
+      for (const key of AGENT_STRIP_KEYS) delete portable[key]
+      return portable as PortableAgent
+    })
+
+  const portableSkills: PortableSkill[] = Object.values(skills).map((skill) => ({
+    originalId: skill.id,
+    name: skill.name,
+    content: skill.content,
+    description: skill.description,
+    tags: skill.tags,
+    scope: skill.scope,
+    author: skill.author,
+    version: skill.version,
+    primaryEnv: skill.primaryEnv,
+    capabilities: skill.capabilities,
+    toolNames: skill.toolNames,
+    frontmatter: skill.frontmatter,
+  }))
+
+  const portableSchedules: PortableSchedule[] = Object.values(schedules)
+    .filter((s) => s.status !== 'archived')
+    .map((schedule) => ({
+      originalId: schedule.id,
+      originalAgentId: schedule.agentId,
+      name: schedule.name,
+      taskPrompt: schedule.taskPrompt,
+      taskMode: schedule.taskMode,
+      message: schedule.message,
+      description: schedule.description,
+      scheduleType: schedule.scheduleType,
+      frequency: schedule.frequency,
+      cron: schedule.cron,
+      atTime: schedule.atTime,
+      intervalMs: schedule.intervalMs,
+      timezone: schedule.timezone,
+      action: schedule.action,
+      path: schedule.path,
+      command: schedule.command,
+    }))
+
+  return {
+    formatVersion: PORTABILITY_FORMAT_VERSION,
+    exportedAt: new Date().toISOString(),
+    agents: portableAgents,
+    skills: portableSkills,
+    schedules: portableSchedules,
+  }
+}

package/src/lib/server/portability/import.ts

@@ -0,0 +1,159 @@
+import { genId } from '@/lib/id'
+import { loadAgents, saveAgents } from '@/lib/server/agents/agent-repository'
+import { loadSkills, saveSkill } from '@/lib/server/skills/skill-repository'
+import { loadSchedules, upsertSchedule } from '@/lib/server/schedules/schedule-repository'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import type { Agent } from '@/types/agent'
+import type { Skill } from '@/types/skill'
+import type { Schedule } from '@/types/schedule'
+import type { PortableManifest, PortableAgent, PortableSkill, PortableSchedule } from './export'
+import { PORTABILITY_FORMAT_VERSION } from './export'
+
+export interface ImportResult {
+  agents: { created: number; skipped: number; names: string[] }
+  skills: { created: number; skipped: number; names: string[] }
+  schedules: { created: number; skipped: number; names: string[] }
+  /** Maps original IDs to new IDs for reference */
+  idMap: Record<string, string>
+}
+
+function deduplicateName(name: string, existingNames: Set<string>): string {
+  if (!existingNames.has(name)) return name
+  let suffix = 2
+  while (existingNames.has(`${name} (${suffix})`)) suffix++
+  return `${name} (${suffix})`
+}
+
+export function importConfig(manifest: PortableManifest): ImportResult {
+  if (manifest.formatVersion > PORTABILITY_FORMAT_VERSION) {
+    throw new Error(`Unsupported format version ${manifest.formatVersion} (max supported: ${PORTABILITY_FORMAT_VERSION})`)
+  }
+
+  const idMap: Record<string, string> = {}
+  const result: ImportResult = {
+    agents: { created: 0, skipped: 0, names: [] },
+    skills: { created: 0, skipped: 0, names: [] },
+    schedules: { created: 0, skipped: 0, names: [] },
+    idMap,
+  }
+
+  // --- Import skills first (agents may reference them) ---
+  const existingSkills = loadSkills()
+  const existingSkillNames = new Set(Object.values(existingSkills).map((s) => s.name))
+
+  for (const portable of manifest.skills) {
+    const name = deduplicateName(portable.name, existingSkillNames)
+    const id = genId()
+    idMap[portable.originalId] = id
+    existingSkillNames.add(name)
+
+    const skill: Skill = {
+      id,
+      name,
+      filename: `${name.toLowerCase().replace(/[^a-z0-9]+/g, '-')}.md`,
+      content: portable.content,
+      description: portable.description,
+      tags: portable.tags,
+      scope: portable.scope || 'global',
+      author: portable.author,
+      version: portable.version,
+      primaryEnv: portable.primaryEnv,
+      capabilities: portable.capabilities,
+      toolNames: portable.toolNames,
+      frontmatter: portable.frontmatter,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    }
+    saveSkill(id, skill)
+    result.skills.created++
+    result.skills.names.push(name)
+  }
+
+  // --- Import agents ---
+  const existingAgents = loadAgents()
+  const existingAgentNames = new Set(Object.values(existingAgents).map((a) => a.name))
+
+  for (const portable of manifest.agents) {
+    const name = deduplicateName(portable.name, existingAgentNames)
+    const id = genId()
+    const now = Date.now()
+    idMap[portable.originalId] = id
+    existingAgentNames.add(name)
+
+    // Remap skill IDs if they were imported
+    const remappedSkillIds = (portable.skillIds || []).map((sid) => idMap[sid] || sid)
+
+    const agent: Agent = {
+      ...(portable as Omit<PortableAgent, 'originalId'>),
+      id,
+      name,
+      skillIds: remappedSkillIds,
+      // Reset runtime fields
+      threadSessionId: null,
+      lastUsedAt: undefined,
+      totalCost: undefined,
+      trashedAt: undefined,
+      credentialId: null,
+      fallbackCredentialIds: [],
+      apiEndpoint: null,
+      createdAt: typeof portable.createdAt === 'number' ? portable.createdAt : now,
+      updatedAt: now,
+    }
+    existingAgents[id] = agent
+    result.agents.created++
+    result.agents.names.push(name)
+  }
+
+  saveAgents(existingAgents)
+
+  // --- Import schedules (need agent ID mapping) ---
+  const existingSchedules = loadSchedules()
+  const existingScheduleNames = new Set(Object.values(existingSchedules).map((s) => s.name))
+
+  for (const portable of manifest.schedules) {
+    const newAgentId = idMap[portable.originalAgentId]
+    if (!newAgentId) {
+      result.schedules.skipped++
+      continue
+    }
+
+    const name = deduplicateName(portable.name, existingScheduleNames)
+    const id = genId()
+    idMap[portable.originalId] = id
+    existingScheduleNames.add(name)
+
+    const schedule: Schedule = {
+      id,
+      name,
+      agentId: newAgentId,
+      taskPrompt: portable.taskPrompt,
+      taskMode: portable.taskMode,
+      message: portable.message,
+      description: portable.description,
+      scheduleType: portable.scheduleType,
+      frequency: portable.frequency,
+      cron: portable.cron,
+      atTime: portable.atTime,
+      intervalMs: portable.intervalMs,
+      timezone: portable.timezone,
+      action: portable.action,
+      path: portable.path,
+      command: portable.command,
+      status: 'paused',
+      createdAt: Date.now(),
+    }
+    upsertSchedule(id, schedule)
+    result.schedules.created++
+    result.schedules.names.push(name)
+  }
+
+  logActivity({
+    entityType: 'system',
+    entityId: 'portability',
+    action: 'imported',
+    actor: 'user',
+    summary: `Imported ${result.agents.created} agents, ${result.skills.created} skills, ${result.schedules.created} schedules`,
+  })
+
+  return result
+}

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

@@ -446,9 +446,6 @@ export function normalizeProtocolSourceRef(run: Partial<ProtocolRun>): ProtocolS
   if (typeof run.parentChatroomId === 'string' && run.parentChatroomId.trim()) {
     return { kind: 'chatroom', chatroomId: run.parentChatroomId.trim() }
   }
-  if (typeof run.missionId === 'string' && run.missionId.trim()) {
-    return { kind: 'mission', missionId: run.missionId.trim() }
-  }
   if (typeof run.taskId === 'string' && run.taskId.trim()) {
     return { kind: 'task', taskId: run.taskId.trim() }
   }
@@ -484,7 +481,6 @@ export function normalizeProtocolRun(run: ProtocolRun): ProtocolRun {
     participantAgentIds: uniqueIds(run.participantAgentIds, 64),
     observerAgentIds: uniqueIds(run.observerAgentIds, 64),
     facilitatorAgentId: typeof run.facilitatorAgentId === 'string' ? run.facilitatorAgentId : null,
-    missionId: typeof run.missionId === 'string' ? run.missionId : null,
     taskId: typeof run.taskId === 'string' ? run.taskId : null,
     sessionId: typeof run.sessionId === 'string' ? run.sessionId : null,
     parentRunId: typeof run.parentRunId === 'string' ? run.parentRunId : null,

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

@@ -13,9 +13,6 @@ import {
   loadChatroom,
   loadChatroomMany,
 } from '@/lib/server/chatrooms/chatroom-repository'
-import {
-  loadMission,
-} from '@/lib/server/missions/mission-repository'
 import {
   loadProtocolRun,
   loadProtocolRuns,
@@ -37,7 +34,6 @@ export function listProtocolTemplates(): ProtocolTemplate[] {
 
 export function listProtocolRuns(options?: {
   status?: ProtocolRunStatus | null
-  missionId?: string | null
   taskId?: string | null
   sessionId?: string | null
   parentChatroomId?: string | null
@@ -51,7 +47,6 @@ export function listProtocolRuns(options?: {
   return Object.values(loadProtocolRuns())
     .map((run) => normalizeProtocolRun(run))
     .filter((run) => !options?.status || run.status === options.status)
-    .filter((run) => !options?.missionId || run.missionId === options.missionId)
     .filter((run) => !options?.taskId || run.taskId === options.taskId)
     .filter((run) => !options?.sessionId || run.sessionId === options.sessionId)
     .filter((run) => !options?.parentChatroomId || run.parentChatroomId === options.parentChatroomId)
@@ -109,7 +104,6 @@ export function getProtocolRunDetail(runId: string): ProtocolRunDetail | null {
     template: loadTemplate(run.templateId),
     transcript: run.transcriptChatroomId ? chatrooms[run.transcriptChatroomId] || null : null,
     parentChatroom: run.parentChatroomId ? chatrooms[run.parentChatroomId] || null : null,
-    linkedMission: run.missionId ? loadMission(run.missionId) : null,
     linkedTask: run.taskId ? loadTask(run.taskId) : null,
     events: listEvents(run.id),
   }

package/src/lib/server/protocols/protocol-run-lifecycle.ts

@@ -19,7 +19,6 @@ import { patchChatroom, upsertChatroom } from '@/lib/server/chatrooms/chatroom-r
 import { loadProtocolRuns } from '@/lib/server/protocols/protocol-run-repository'
 import { loadTask } from '@/lib/server/tasks/task-repository'
 import { errorMessage, hmrSingleton } from '@/lib/shared-utils'
-import { requestMissionTick } from '@/lib/server/missions/mission-service'
 import { cleanText, isDiscussionStepKind, now, uniqueIds } from '@/lib/server/protocols/protocol-types'
 import type { CreateProtocolRunInput, ProtocolRunActionInput, ProtocolRunDeps } from '@/lib/server/protocols/protocol-types'
 import { deriveDisplayPhasesFromSteps, loadProtocolRunById, normalizeProtocolRun, resolveRunSteps } from '@/lib/server/protocols/protocol-normalization'
@@ -224,11 +223,10 @@ export function createProtocolRun(input: CreateProtocolRunInput, deps?: Protocol
     : null
   const sourceRef = input.sourceRef || (
     input.parentChatroomId ? { kind: 'chatroom', chatroomId: input.parentChatroomId } as ProtocolSourceRef
-      : input.missionId ? { kind: 'mission', missionId: input.missionId } as ProtocolSourceRef
-        : input.taskId ? { kind: 'task', taskId: input.taskId } as ProtocolSourceRef
-          : input.scheduleId ? { kind: 'schedule', scheduleId: input.scheduleId } as ProtocolSourceRef
-            : input.sessionId ? { kind: 'session', sessionId: input.sessionId } as ProtocolSourceRef
-              : { kind: 'manual' } as ProtocolSourceRef
+      : input.taskId ? { kind: 'task', taskId: input.taskId } as ProtocolSourceRef
+        : input.scheduleId ? { kind: 'schedule', scheduleId: input.scheduleId } as ProtocolSourceRef
+          : input.sessionId ? { kind: 'session', sessionId: input.sessionId } as ProtocolSourceRef
+            : { kind: 'manual' } as ProtocolSourceRef
   )
   const runId = genId()
   if (transcript) {
@@ -246,7 +244,6 @@ export function createProtocolRun(input: CreateProtocolRunInput, deps?: Protocol
     participantAgentIds,
     facilitatorAgentId: cleanText(input.facilitatorAgentId, 64) || participantAgentIds[0] || null,
     observerAgentIds: uniqueIds(input.observerAgentIds, 32),
-    missionId: cleanText(input.missionId, 64) || null,
     taskId: cleanText(input.taskId, 64) || null,
     sessionId: cleanText(input.sessionId, 64) || null,
     parentRunId: cleanText(input.parentRunId, 64) || null,
@@ -288,9 +285,6 @@ export function createProtocolRun(input: CreateProtocolRunInput, deps?: Protocol
       transcriptChatroomId: run.transcriptChatroomId,
     },
   }, deps)
-  if (run.missionId) {
-    requestMissionTick(run.missionId, 'protocol_run_created', { protocolRunId: run.id })
-  }
   if (input.autoStart !== false) {
     requestProtocolRunExecution(run.id, deps)
   }
@@ -594,7 +588,6 @@ export function launchProtocolRunForSchedule(schedule: Schedule): ProtocolRun {
     observerAgentIds: uniqueIds(schedule.protocolObserverAgentIds, 32),
     scheduleId: schedule.id,
     sessionId: schedule.createdInSessionId || null,
-    missionId: schedule.linkedMissionId || null,
     sourceRef: { kind: 'schedule', scheduleId: schedule.id },
     autoStart: true,
     parentChatroomId: null,
@@ -607,31 +600,11 @@ export function launchProtocolRunForSchedule(schedule: Schedule): ProtocolRun {
   })
 }
 
-export function launchProtocolRunForMission(input: {
-  missionId: string
-  title: string
-  participantAgentIds: string[]
-  facilitatorAgentId?: string | null
-  config?: ProtocolRunConfig | null
-  templateId?: string | null
-}): ProtocolRun {
-  return createProtocolRun({
-    title: input.title,
-    templateId: input.templateId || 'facilitated_discussion',
-    participantAgentIds: input.participantAgentIds,
-    facilitatorAgentId: input.facilitatorAgentId || null,
-    missionId: input.missionId,
-    sourceRef: { kind: 'mission', missionId: input.missionId },
-    config: input.config || null,
-  })
-}
-
 export function launchProtocolRunForTask(input: {
   taskId: string
   title: string
   participantAgentIds: string[]
   facilitatorAgentId?: string | null
-  missionId?: string | null
   config?: ProtocolRunConfig | null
   templateId?: string | null
 }): ProtocolRun {
@@ -640,7 +613,6 @@ export function launchProtocolRunForTask(input: {
     templateId: input.templateId || 'facilitated_discussion',
     participantAgentIds: input.participantAgentIds,
     facilitatorAgentId: input.facilitatorAgentId || null,
-    missionId: input.missionId || null,
     taskId: input.taskId,
     sourceRef: { kind: 'task', taskId: input.taskId },
     config: input.config || null,

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

@@ -43,7 +43,6 @@ export {
   runProtocolRun,
   performProtocolRunAction,
   launchProtocolRunForSchedule,
-  launchProtocolRunForMission,
   launchProtocolRunForTask,
 } from '@/lib/server/protocols/protocol-run-lifecycle'
 

package/src/lib/server/protocols/protocol-step-helpers.ts

@@ -36,7 +36,6 @@ import {
   updateRun,
 } from '@/lib/server/protocols/protocol-agent-turn'
 import { isTerminalProtocolRunStatus } from '@/lib/server/protocols/protocol-templates'
-import { requestMissionTick } from '@/lib/server/missions/mission-service'
 
 // ---- BranchDecisionSchema ----
 
@@ -329,9 +328,6 @@ export function completeProtocolRun(run: ProtocolRun, deps?: ProtocolRunDeps, su
     summary,
   }, deps)
   emitSummaryToParentChatroom(completed, deps)
-  if (completed.missionId) {
-    requestMissionTick(completed.missionId, 'protocol_run_completed', { protocolRunId: completed.id })
-  }
   return completed
 }
 

package/src/lib/server/protocols/protocol-step-processors.ts

@@ -16,7 +16,6 @@ import { errorMessage } from '@/lib/shared-utils'
 import { getAgents } from '@/lib/server/agents/agent-repository'
 import { upsertTask } from '@/lib/server/tasks/task-repository'
 import { notify } from '@/lib/server/ws-hub'
-import { ensureMissionForTask } from '@/lib/server/missions/mission-service'
 import { enqueueTask } from '@/lib/server/runtime/queue'
 import { cleanText, isDiscussionStepKind, now, uniqueIds } from '@/lib/server/protocols/protocol-types'
 import type { ProtocolRunDeps } from '@/lib/server/protocols/protocol-types'
@@ -227,7 +226,6 @@ export async function processEmitTasksPhase(run: ProtocolRun, phase: ProtocolPha
     ...extracted.map((item) => item.agentId || ''),
   ], 64))
   const createdTaskIds: string[] = []
-  const linkedMissionId = typeof run.missionId === 'string' ? run.missionId : null
   const taskProjectId = run.config?.taskProjectId || null
   for (const item of extracted) {
     const assignedAgentId = item.agentId && agents[item.agentId] ? item.agentId : fallbackAssignee
@@ -238,7 +236,6 @@ export async function processEmitTasksPhase(run: ProtocolRun, phase: ProtocolPha
       description: cleanText(item.description, 1_000) || cleanText(artifact.content, 800),
       status: 'backlog',
       agentId: assignedAgentId,
-      missionId: linkedMissionId,
       projectId: taskProjectId || undefined,
       createdByAgentId: chooseFacilitator(run),
       createdInSessionId: run.sessionId || null,
@@ -248,7 +245,6 @@ export async function processEmitTasksPhase(run: ProtocolRun, phase: ProtocolPha
       tags: ['structured-session'],
     }
     upsertTask(task.id, task)
-    ensureMissionForTask(task, { source: 'manual' })
     createdTaskIds.push(task.id)
     appendProtocolEvent(run.id, {
       type: 'task_emitted',
@@ -607,7 +603,6 @@ export function processDispatchTaskPhase(run: ProtocolRun, phase: ProtocolPhaseD
     status: 'queued',
     agentId,
     protocolRunId: run.id,
-    missionId: run.missionId || null,
     queuedAt: now(deps),
     createdAt: now(deps),
     updatedAt: now(deps),
@@ -656,7 +651,6 @@ export function processDispatchDelegationPhase(run: ProtocolRun, phase: Protocol
     status: 'queued',
     agentId: config.agentId,
     protocolRunId: run.id,
-    missionId: run.missionId || null,
     sourceType: 'delegation',
     queuedAt: now(deps),
     createdAt: now(deps),

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

@@ -90,7 +90,6 @@ export async function processSwarmStep(run: ProtocolRun, step: ProtocolStepDefin
         status: 'queued',
         agentId,
         protocolRunId: started.id,
-        missionId: started.missionId || null,
         sourceType: 'delegation',
         queuedAt: now(deps),
         createdAt: now(deps),
@@ -189,7 +188,6 @@ export function claimSwarmWorkItem(
     status: 'queued',
     agentId,
     protocolRunId: runId,
-    missionId: run.missionId || null,
     sourceType: 'delegation',
     queuedAt: now(deps),
     createdAt: now(deps),