@swarmclawai/swarmclaw 0.7.2 → 0.7.3

package/src/lib/server/memory-db.ts

@@ -14,6 +14,7 @@ import {
   traverseLinkedMemoryGraph,
   type MemoryLookupLimits,
 } from './memory-graph'
+import { isWorkingMemoryCategory } from './memory-tiers'
 
 import { DATA_DIR } from './data-dir'
 
@@ -1203,8 +1204,7 @@ function initDb() {
         if (seenCanonical.has(keyCanonical)) canonicalDuplicateCandidates++
         else seenCanonical.add(keyCanonical)
 
-        const category = String(row.category || '').toLowerCase()
-        const isWorkingLike = category === 'execution' || category === 'working' || category === 'scratch'
+        const isWorkingLike = isWorkingMemoryCategory(row.category)
         if (isWorkingLike && (row.updatedAt || row.createdAt || 0) < cutoff) staleWorkingCandidates++
       }
 
@@ -1303,8 +1303,7 @@ function initDb() {
       if (pruneWorking && toDelete.size < deleteBudget) {
         for (const row of rows) {
           if (toDelete.has(row.id)) continue
-          const category = String(row.category || '').toLowerCase()
-          const isWorkingLike = category === 'execution' || category === 'working' || category === 'scratch'
+          const isWorkingLike = isWorkingMemoryCategory(row.category)
           const updatedAt = row.updatedAt || row.createdAt || 0
           if (isWorkingLike && updatedAt < cutoff) toDelete.add(row.id)
           if (toDelete.size >= deleteBudget) break
@@ -1323,8 +1322,7 @@ function initDb() {
         const deletedSet = new Set(deleteIds)
         for (const row of rows) {
           if (!deletedSet.has(row.id)) continue
-          const category = String(row.category || '').toLowerCase()
-          const isWorkingLike = category === 'execution' || category === 'working' || category === 'scratch'
+          const isWorkingLike = isWorkingMemoryCategory(row.category)
           if (isWorkingLike) pruned++
           else deduped++
         }

package/src/lib/server/memory-tiers.ts

@@ -0,0 +1,40 @@
+import type { MemoryEntry } from '@/types'
+
+export type MemoryTier = 'working' | 'durable' | 'archive'
+
+const WORKING_CATEGORIES = new Set(['execution', 'working', 'scratch', 'breadcrumb'])
+const ARCHIVE_CATEGORIES = new Set(['session_archive'])
+
+export function getMemoryTierForCategory(category: unknown): MemoryTier {
+  const normalized = typeof category === 'string' ? category.trim().toLowerCase() : ''
+  if (ARCHIVE_CATEGORIES.has(normalized)) return 'archive'
+  if (WORKING_CATEGORIES.has(normalized)) return 'working'
+  return 'durable'
+}
+
+export function getMemoryTier(entry: Pick<MemoryEntry, 'category' | 'metadata'>): MemoryTier {
+  const metadataTier = typeof entry.metadata?.tier === 'string' ? entry.metadata.tier.trim().toLowerCase() : ''
+  if (metadataTier === 'archive' || metadataTier === 'session_archive') return 'archive'
+  if (metadataTier === 'working') return 'working'
+  if (metadataTier === 'durable') return 'durable'
+  return getMemoryTierForCategory(entry.category)
+}
+
+export function partitionMemoriesByTier<T extends Pick<MemoryEntry, 'category' | 'metadata'>>(entries: T[]) {
+  const working: T[] = []
+  const durable: T[] = []
+  const archive: T[] = []
+
+  for (const entry of entries) {
+    const tier = getMemoryTier(entry)
+    if (tier === 'working') working.push(entry)
+    else if (tier === 'archive') archive.push(entry)
+    else durable.push(entry)
+  }
+
+  return { working, durable, archive }
+}
+
+export function isWorkingMemoryCategory(category: unknown): boolean {
+  return getMemoryTierForCategory(category) === 'working'
+}

package/src/lib/server/openclaw-agent-resolver.test.ts

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import type { Agent } from '@/types'
+import {
+  resolveOpenClawGatewayAgentIdFromList,
+  type OpenClawGatewayAgentSummary,
+} from './openclaw-agent-resolver'
+
+function makeOpenClawAgent(overrides: Partial<Agent> = {}): Agent {
+  const now = Date.now()
+  return {
+    id: 'f4535f26',
+    name: 'OpenClaw Ops',
+    description: '',
+    systemPrompt: '',
+    provider: 'openclaw',
+    model: 'openclaw-default',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  }
+}
+
+test('resolveOpenClawGatewayAgentIdFromList matches a local OpenClaw agent by normalized name', () => {
+  const gatewayAgents: OpenClawGatewayAgentSummary[] = [
+    { id: 'main', name: 'Main' },
+    { id: 'openclaw-ops', name: 'OpenClaw Ops' },
+  ]
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: 'f4535f26',
+    gatewayAgents,
+    localAgent: makeOpenClawAgent(),
+  })
+  assert.equal(resolved, 'openclaw-ops')
+})
+
+test('resolveOpenClawGatewayAgentIdFromList preserves direct gateway ids', () => {
+  const gatewayAgents: OpenClawGatewayAgentSummary[] = [
+    { id: 'main', name: 'Main' },
+  ]
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: 'main',
+    gatewayAgents,
+  })
+  assert.equal(resolved, 'main')
+})
+
+test('resolveOpenClawGatewayAgentIdFromList can match identity names when display names differ', () => {
+  const gatewayAgents: OpenClawGatewayAgentSummary[] = [
+    { id: 'research-ops', identity: { name: 'Research Ops' } },
+  ]
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: 'agent-123',
+    gatewayAgents,
+    localAgent: makeOpenClawAgent({ id: 'agent-123', name: 'Research Ops' }),
+  })
+  assert.equal(resolved, 'research-ops')
+})
+
+test('single-agent gateway can back a local OpenClaw provider agent without an explicit name match', async () => {
+  const gatewayAgents: OpenClawGatewayAgentSummary[] = [
+    { id: 'main', name: 'Main' },
+  ]
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: 'f4535f26',
+    gatewayAgents,
+    localAgent: makeOpenClawAgent({ name: 'OpenClaw-2' }),
+  })
+  assert.equal(resolved, 'main')
+})

package/src/lib/server/openclaw-agent-resolver.ts

@@ -0,0 +1,128 @@
+import type { Agent } from '@/types'
+import { normalizeOpenClawAgentId } from '@/lib/openclaw-agent-id'
+import { ensureGatewayConnected, type OpenClawGateway } from './openclaw-gateway'
+import { loadAgents } from './storage'
+
+export interface OpenClawGatewayAgentSummary {
+  id: string
+  name?: string
+  identity?: {
+    name?: string
+  } | null
+}
+
+interface OpenClawGatewayAgentsList {
+  defaultId?: string
+  agents?: OpenClawGatewayAgentSummary[]
+}
+
+function addTextCandidate(target: Set<string>, value: string | undefined | null) {
+  const trimmed = (value ?? '').trim()
+  if (trimmed) {
+    target.add(trimmed.toLowerCase())
+  }
+}
+
+function addNormalizedCandidate(target: Set<string>, value: string | undefined | null) {
+  const trimmed = (value ?? '').trim()
+  if (trimmed) {
+    target.add(normalizeOpenClawAgentId(trimmed))
+  }
+}
+
+export function resolveOpenClawGatewayAgentIdFromList(params: {
+  agentRef: string
+  gatewayAgents: OpenClawGatewayAgentSummary[]
+  localAgent?: Agent | null
+}): string | null {
+  const rawRef = params.agentRef.trim()
+  if (!rawRef) {
+    return null
+  }
+
+  const exactTextCandidates = new Set<string>()
+  const normalizedCandidates = new Set<string>()
+
+  addTextCandidate(exactTextCandidates, rawRef)
+  addNormalizedCandidate(normalizedCandidates, rawRef)
+
+  if (params.localAgent) {
+    addTextCandidate(exactTextCandidates, params.localAgent.id)
+    addTextCandidate(exactTextCandidates, params.localAgent.name)
+    addNormalizedCandidate(normalizedCandidates, params.localAgent.id)
+    addNormalizedCandidate(normalizedCandidates, params.localAgent.name)
+  }
+
+  for (const gatewayAgent of params.gatewayAgents) {
+    if (exactTextCandidates.has(gatewayAgent.id.trim().toLowerCase())) {
+      return gatewayAgent.id
+    }
+  }
+
+  for (const gatewayAgent of params.gatewayAgents) {
+    if (normalizedCandidates.has(normalizeOpenClawAgentId(gatewayAgent.id))) {
+      return gatewayAgent.id
+    }
+  }
+
+  for (const gatewayAgent of params.gatewayAgents) {
+    const labels = [gatewayAgent.name, gatewayAgent.identity?.name]
+    for (const label of labels) {
+      if (!label?.trim()) continue
+      if (exactTextCandidates.has(label.trim().toLowerCase())) {
+        return gatewayAgent.id
+      }
+    }
+  }
+
+  for (const gatewayAgent of params.gatewayAgents) {
+    const labels = [gatewayAgent.name, gatewayAgent.identity?.name]
+    for (const label of labels) {
+      if (!label?.trim()) continue
+      if (normalizedCandidates.has(normalizeOpenClawAgentId(label))) {
+        return gatewayAgent.id
+      }
+    }
+  }
+
+  if (params.localAgent && params.gatewayAgents.length === 1) {
+    return params.gatewayAgents[0].id
+  }
+
+  return null
+}
+
+export async function resolveOpenClawGatewayAgentId(
+  agentRef: string,
+  gatewayArg?: OpenClawGateway | null,
+): Promise<string> {
+  const trimmedRef = agentRef.trim()
+  if (!trimmedRef) {
+    throw new Error('Missing agentId')
+  }
+
+  const localAgents = loadAgents({ includeTrashed: true }) as Record<string, Agent>
+  const localAgent = localAgents[trimmedRef] || null
+  if (localAgent && localAgent.provider !== 'openclaw') {
+    throw new Error(`Agent "${localAgent.name}" is not an OpenClaw agent`)
+  }
+
+  const gateway = gatewayArg ?? await ensureGatewayConnected()
+  if (!gateway) {
+    throw new Error('OpenClaw gateway not connected')
+  }
+
+  const result = await gateway.rpc('agents.list', {}) as OpenClawGatewayAgentsList | undefined
+  const gatewayAgents = Array.isArray(result?.agents) ? result.agents : []
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: trimmedRef,
+    gatewayAgents,
+    localAgent,
+  })
+  if (resolved) {
+    return resolved
+  }
+
+  const label = localAgent?.name?.trim() || trimmedRef
+  throw new Error(`OpenClaw gateway agent not found for "${label}"`)
+}

package/src/lib/server/openclaw-exec-config.ts

@@ -7,12 +7,12 @@ const DEFAULT_CONFIG: ExecApprovalConfig = {
   patterns: [],
 }
 
-/** Fetch exec approval config from gateway for a given agent */
-export async function getExecConfig(agentId: string): Promise<ExecApprovalSnapshot> {
+/** Fetch the gateway's global exec approval config. */
+export async function getExecConfig(_agentId?: string): Promise<ExecApprovalSnapshot> {
   const gw = await ensureGatewayConnected()
   if (!gw) throw new Error('Gateway not connected')
 
-  const result = await gw.rpc('exec.approvals.get', { agentId }) as ExecApprovalSnapshot | undefined
+  const result = await gw.rpc('exec.approvals.get', {}) as ExecApprovalSnapshot | undefined
   if (!result) {
     return { path: '', exists: false, hash: '', file: { ...DEFAULT_CONFIG } }
   }
@@ -21,7 +21,7 @@ export async function getExecConfig(agentId: string): Promise<ExecApprovalSnapsh
 
 /** Save exec approval config with hash-based conflict retry (up to 3 attempts) */
 export async function setExecConfig(
-  agentId: string,
+  _agentId: string,
   config: ExecApprovalConfig,
   baseHash: string,
 ): Promise<{ ok: boolean; hash: string }> {
@@ -32,7 +32,6 @@ export async function setExecConfig(
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
       const result = await gw.rpc('exec.approvals.set', {
-        agentId,
         file: config,
         baseHash: currentHash,
       }) as { hash?: string } | undefined
@@ -41,7 +40,7 @@ export async function setExecConfig(
       const msg = err instanceof Error ? err.message : String(err)
       if (msg.includes('conflict') && attempt < 2) {
         // Re-fetch to get fresh hash
-        const fresh = await getExecConfig(agentId)
+        const fresh = await getExecConfig()
         currentHash = fresh.hash
         continue
       }

package/src/lib/server/openclaw-skills-normalize.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { normalizeOpenClawSkillsPayload } from './openclaw-skills-normalize'
+
+test('normalizeOpenClawSkillsPayload maps gateway skill reports into UI entries', () => {
+  const normalized = normalizeOpenClawSkillsPayload({
+    workspaceDir: '/tmp/workspace',
+    skills: [
+      {
+        name: 'github',
+        description: 'GitHub operations',
+        source: 'openclaw-bundled',
+        eligible: true,
+        requirements: {
+          bins: ['gh'],
+          anyBins: [['git', 'jj']],
+          env: ['GH_TOKEN'],
+        },
+        missing: {
+          config: ['channels.github'],
+        },
+        install: [
+          { kind: 'brew', label: 'Install GitHub CLI', bins: ['gh'] },
+        ],
+        configChecks: [
+          { path: 'channels.github', satisfied: false },
+        ],
+        skillKey: 'github',
+        baseDir: '/tmp/github',
+      },
+    ],
+  })
+
+  assert.equal(normalized.length, 1)
+  assert.deepEqual(normalized[0], {
+    name: 'github',
+    description: 'GitHub operations',
+    source: 'bundled',
+    eligible: true,
+    missing: ['config channels.github'],
+    disabled: false,
+    installOptions: [
+      { kind: 'brew', label: 'Install GitHub CLI', bins: ['gh'] },
+    ],
+    skillRequirements: {
+      bins: ['gh'],
+      anyBins: [['git', 'jj']],
+      env: ['GH_TOKEN'],
+      config: undefined,
+      os: undefined,
+    },
+    configChecks: [{ key: 'channels.github', ok: false }],
+    skillKey: 'github',
+    baseDir: '/tmp/github',
+  })
+})

package/src/lib/server/openclaw-skills-normalize.ts

@@ -0,0 +1,136 @@
+import type { OpenClawSkillEntry, SkillInstallOption, SkillRequirements } from '@/types'
+
+interface GatewayConfigCheck {
+  path?: string
+  satisfied?: boolean
+}
+
+interface GatewayInstallOption {
+  kind?: string
+  label?: string
+  bins?: string[]
+}
+
+interface GatewaySkillRequirements {
+  bins?: string[]
+  anyBins?: string[][]
+  env?: string[]
+  config?: string[]
+  os?: string[]
+}
+
+interface GatewaySkillEntry {
+  name?: string
+  description?: string
+  source?: string
+  eligible?: boolean
+  requirements?: GatewaySkillRequirements
+  missing?: GatewaySkillRequirements
+  disabled?: boolean
+  install?: GatewayInstallOption[]
+  configChecks?: GatewayConfigCheck[]
+  skillKey?: string
+  baseDir?: string
+}
+
+interface GatewaySkillsStatusPayload {
+  skills?: GatewaySkillEntry[]
+}
+
+function uniq(values: Array<string | undefined | null>): string[] {
+  return [...new Set(values.map((value) => (value ?? '').trim()).filter(Boolean))]
+}
+
+function normalizeSource(source: string | undefined): OpenClawSkillEntry['source'] {
+  switch ((source ?? '').trim()) {
+    case 'openclaw-bundled':
+    case 'bundled':
+      return 'bundled'
+    case 'managed':
+      return 'managed'
+    case 'personal':
+      return 'personal'
+    case 'workspace':
+      return 'workspace'
+    default:
+      return 'workspace'
+  }
+}
+
+function normalizeInstallOptions(install: GatewayInstallOption[] | undefined): SkillInstallOption[] | undefined {
+  if (!Array.isArray(install) || !install.length) return undefined
+  const normalized = install
+    .map((entry) => {
+      const kind = (entry.kind ?? '').trim()
+      if (!kind || !entry.label?.trim()) return null
+      if (!['brew', 'node', 'go', 'uv', 'download'].includes(kind)) return null
+      return {
+        kind: kind as SkillInstallOption['kind'],
+        label: entry.label.trim(),
+        bins: Array.isArray(entry.bins) ? uniq(entry.bins) : undefined,
+      } satisfies SkillInstallOption
+    })
+    .filter((value): value is NonNullable<typeof value> => value !== null)
+  return normalized.length ? normalized : undefined
+}
+
+function normalizeRequirements(input: GatewaySkillRequirements | undefined): SkillRequirements | undefined {
+  if (!input || typeof input !== 'object') return undefined
+  const bins = Array.isArray(input.bins) ? uniq(input.bins) : undefined
+  const anyBins = Array.isArray(input.anyBins)
+    ? input.anyBins
+        .map((group) => Array.isArray(group) ? uniq(group) : [])
+        .filter((group) => group.length > 0)
+    : undefined
+  const env = Array.isArray(input.env) ? uniq(input.env) : undefined
+  const config = Array.isArray(input.config) ? uniq(input.config) : undefined
+  const os = Array.isArray(input.os) ? uniq(input.os) : undefined
+  if (!bins && !anyBins && !env && !config && !os) return undefined
+  return { bins, anyBins, env, config, os }
+}
+
+function flattenMissing(input: GatewaySkillRequirements | undefined): string[] | undefined {
+  if (!input || typeof input !== 'object') return undefined
+  const out: string[] = []
+  for (const value of Array.isArray(input.bins) ? uniq(input.bins) : []) out.push(value)
+  for (const group of Array.isArray(input.anyBins) ? input.anyBins : []) {
+    const normalized = Array.isArray(group) ? uniq(group) : []
+    if (normalized.length) out.push(`one of: ${normalized.join(' | ')}`)
+  }
+  for (const value of Array.isArray(input.env) ? uniq(input.env) : []) out.push(`env ${value}`)
+  for (const value of Array.isArray(input.config) ? uniq(input.config) : []) out.push(`config ${value}`)
+  for (const value of Array.isArray(input.os) ? uniq(input.os) : []) out.push(`os ${value}`)
+  return out.length ? out : undefined
+}
+
+export function normalizeOpenClawSkillsPayload(payload: unknown): OpenClawSkillEntry[] {
+  const rawSkills = Array.isArray(payload)
+    ? payload as GatewaySkillEntry[]
+    : Array.isArray((payload as GatewaySkillsStatusPayload | null | undefined)?.skills)
+      ? (payload as GatewaySkillsStatusPayload).skills!
+      : []
+
+  return rawSkills
+    .map((skill) => {
+      const name = skill.name?.trim()
+      if (!name) return null
+      return {
+        name,
+        description: skill.description?.trim() || undefined,
+        source: normalizeSource(skill.source),
+        eligible: skill.eligible === true,
+        missing: flattenMissing(skill.missing),
+        disabled: skill.disabled === true,
+        installOptions: normalizeInstallOptions(skill.install),
+        skillRequirements: normalizeRequirements(skill.requirements),
+        configChecks: Array.isArray(skill.configChecks)
+          ? skill.configChecks
+              .filter((check) => check.path?.trim())
+              .map((check) => ({ key: check.path!.trim(), ok: check.satisfied === true }))
+          : undefined,
+        skillKey: skill.skillKey?.trim() || undefined,
+        baseDir: skill.baseDir?.trim() || undefined,
+      } satisfies OpenClawSkillEntry
+    })
+    .filter((skill): skill is NonNullable<typeof skill> => skill !== null)
+}

package/src/lib/server/openclaw-sync.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
 import { DATA_DIR } from './data-dir'
+import { normalizeOpenClawAgentId } from '@/lib/openclaw-agent-id'
 import { loadSettings, loadAgents, saveAgents, loadSchedules, saveSchedules, loadCredentials, decryptKey, encryptKey } from './storage'
 import { getMemoryDb } from './memory-db'
 import type { AppSettings, MemoryEntry, Schedule } from '@/types'
@@ -182,7 +183,7 @@ export function pushAgentToOpenClaw(agentId: string): { written: string[] } {
   const agent = agents[agentId]
   if (!agent) throw new Error(`Agent not found: ${agentId}`)
 
-  const agentDir = path.join(config.workspacePath, 'agents', agent.name.toLowerCase().replace(/\s+/g, '-'))
+  const agentDir = path.join(config.workspacePath, 'agents', normalizeOpenClawAgentId(agent.name))
   ensureDir(agentDir)
 
   const written: string[] = []
@@ -214,7 +215,7 @@ export function pullAgentFromOpenClaw(agentId: string): { updated: string[] } {
   const agent = agents[agentId]
   if (!agent) throw new Error(`Agent not found: ${agentId}`)
 
-  const agentDir = path.join(config.workspacePath, 'agents', agent.name.toLowerCase().replace(/\s+/g, '-'))
+  const agentDir = path.join(config.workspacePath, 'agents', normalizeOpenClawAgentId(agent.name))
   const updated: string[] = []
 
   const soulPath = path.join(agentDir, 'SOUL.md')

package/src/lib/server/orchestrator-lg.ts

@@ -13,6 +13,7 @@ import { notify } from './ws-hub'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { getPluginManager } from './plugins'
+import './builtin-plugins'
 import { genId } from '@/lib/id'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 import type { Agent, TaskComment, MessageToolEvent } from '@/types'
@@ -118,7 +119,7 @@ async function executeSubTaskViaCli(agent: Agent, task: string, parentSessionId:
     messages: [],
     createdAt: Date.now(),
     lastActiveAt: Date.now(),
-    sessionType: 'orchestrated' as const,
+    sessionType: 'human' as const,
     agentId: agent.id,
     parentSessionId,
     plugins: agent.plugins || agent.tools || [],
@@ -177,7 +178,11 @@ export async function executeLangGraphOrchestrator(
         return `Agent "${agentName}" not found. Available: ${agents.map((a) => a.name).join(', ')}`
       }
       console.log(`[orchestrator-lg] Delegating to ${agent.name}: ${agentTask.slice(0, 80)}`)
-      getPluginManager().runHook('onAgentDelegation', { sourceAgentId: orchestrator.id, targetAgentId: agent.id, task: agentTask })
+      getPluginManager().runHook(
+        'onAgentDelegation',
+        { sourceAgentId: orchestrator.id, targetAgentId: agent.id, task: agentTask },
+        { enabledIds: orchestrator.plugins || [] },
+      )
       const result = await executeSubTaskViaCli(agent, agentTask, sessionId)
       saveMessage(sessionId, 'assistant', `Delegated to ${agent.name}: ${agentTask.slice(0, 100)}`, [{
         name: 'delegate_to_agent',
@@ -393,6 +398,7 @@ export async function executeLangGraphOrchestrator(
 
   const checkpointSaver = getCheckpointSaver()
   const isStrictMode = settings.capabilityPolicyMode === 'strict'
+  const approvalInterruptsEnabled = isStrictMode && settings.approvalsEnabled !== false
   const allTools = [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool]
   const llmWithTools = llm.bindTools(allTools)
   const toolNode = new ToolNode(allTools)
@@ -472,7 +478,7 @@ export async function executeLangGraphOrchestrator(
 
   const compiledGraph = graph.compile({
     checkpointer: checkpointSaver,
-    ...(isStrictMode ? { interruptBefore: ['tools'] } : {}),
+    ...(approvalInterruptsEnabled ? { interruptBefore: ['tools'] } : {}),
   })
 
   // Export graph structure for introspection
@@ -534,7 +540,7 @@ export async function executeLangGraphOrchestrator(
     }
 
     // Check for interrupt (paused before tool execution in strict mode)
-    if (isStrictMode && taskId) {
+    if (approvalInterruptsEnabled && taskId) {
       const state = await compiledGraph.getState({ configurable: { thread_id: threadId } })
       const nextNodes = state?.next || []
       if (nextNodes.includes('tools')) {
@@ -628,7 +634,11 @@ export async function resumeLangGraphOrchestrator(
     async ({ agentName, task: agentTask }) => {
       const agent = agents.find((a) => a.name.toLowerCase() === agentName.toLowerCase())
       if (!agent) return `Agent "${agentName}" not found. Available: ${agents.map((a) => a.name).join(', ')}`
-      getPluginManager().runHook('onAgentDelegation', { sourceAgentId: orchestrator.id, targetAgentId: agent.id, task: agentTask })
+      getPluginManager().runHook(
+        'onAgentDelegation',
+        { sourceAgentId: orchestrator.id, targetAgentId: agent.id, task: agentTask },
+        { enabledIds: orchestrator.plugins || [] },
+      )
       const result = await executeSubTaskViaCli(agent, agentTask, sessionId)
       saveMessage(sessionId, 'assistant', `Delegated to ${agent.name}: ${agentTask.slice(0, 100)}`, [{
         name: 'delegate_to_agent',
@@ -753,6 +763,7 @@ export async function resumeLangGraphOrchestrator(
   const checkpointSaver = getCheckpointSaver()
   const settings = loadSettings()
   const isStrictMode = settings.capabilityPolicyMode === 'strict'
+  const approvalInterruptsEnabled = isStrictMode && settings.approvalsEnabled !== false
 
   const allTools = [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool]
   const llmWithTools = llm.bindTools(allTools)
@@ -782,7 +793,7 @@ export async function resumeLangGraphOrchestrator(
     .addEdge('router', 'agent')
     .compile({
       checkpointer: checkpointSaver,
-      ...(isStrictMode ? { interruptBefore: ['tools'] } : {}),
+      ...(approvalInterruptsEnabled ? { interruptBefore: ['tools'] } : {}),
     })
 
   let finalResult = ''

package/src/lib/server/orchestrator.ts

@@ -42,7 +42,7 @@ export function createOrchestratorSession(
     messages: [] as any[],
     createdAt: Date.now(),
     lastActiveAt: Date.now(),
-    sessionType: 'orchestrated' as const,
+    sessionType: 'human' as const,
     agentId: orchestrator.id,
     parentSessionId: parentSessionId || null,
     plugins: Array.isArray(orchestrator.plugins) ? [...orchestrator.plugins] : (Array.isArray(orchestrator.tools) ? [...orchestrator.tools] : []),
@@ -288,7 +288,7 @@ async function executeSubTask(
     messages: [] as any[],
     createdAt: Date.now(),
     lastActiveAt: Date.now(),
-    sessionType: 'orchestrated' as const,
+    sessionType: 'human' as const,
     agentId: agent.id,
     parentSessionId,
     plugins: agent.plugins || agent.tools || [],

package/src/lib/server/playwright-proxy.mjs

@@ -11,9 +11,33 @@ import path from 'path'
 const UPLOAD_DIR = process.env.SWARMCLAW_UPLOAD_DIR || path.join(process.env.DATA_DIR || path.join(process.cwd(), 'data'), 'uploads')
 if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
 
-const child = spawn('npx', ['@playwright/mcp@latest'], {
-  stdio: ['pipe', 'pipe', 'pipe'],
-})
+function resolvePlaywrightCli() {
+  const candidates = [
+    path.join(process.cwd(), 'node_modules', '@playwright', 'mcp', 'cli.js'),
+    path.join(process.cwd(), '[project]', 'node_modules', '@playwright', 'mcp', 'cli.js'),
+  ]
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null
+}
+
+function sanitizePlaywrightEnv(baseEnv) {
+  const env = { ...baseEnv }
+  for (const key of Object.keys(env)) {
+    if (!key.toUpperCase().startsWith('PLAYWRIGHT_MCP_')) continue
+    delete env[key]
+  }
+  return env
+}
+
+const cliPath = resolvePlaywrightCli()
+const child = cliPath
+  ? spawn(process.execPath, [cliPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: sanitizePlaywrightEnv(process.env),
+    })
+  : spawn('npx', ['@playwright/mcp@latest'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: sanitizePlaywrightEnv(process.env),
+    })
 
 // Forward stdin → child
 process.stdin.on('data', (chunk) => child.stdin.write(chunk))