@swarmclawai/swarmclaw 0.7.8 → 0.8.0

package/src/lib/schedule-dedupe.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
-import { findDuplicateSchedule, getScheduleSignatureKey, type ScheduleLike } from './schedule-dedupe.ts'
+import { findDuplicateSchedule, findEquivalentSchedules, getScheduleSignatureKey, type ScheduleLike } from './schedule-dedupe.ts'
 
 test('findDuplicateSchedule matches active interval schedules with normalized prompts', () => {
   const schedules: Record<string, ScheduleLike> = {
@@ -82,3 +82,68 @@ test('getScheduleSignatureKey is stable for equivalent schedules', () => {
   assert.equal(keyA, keyB)
   assert.notEqual(keyA, keyC)
 })
+
+test('findDuplicateSchedule fuzzy-matches same-session recurring reminders with different wording and cadence shape', () => {
+  const schedules: Record<string, ScheduleLike> = {
+    daily1: {
+      id: 'daily1',
+      agentId: 'assistant',
+      taskPrompt: 'Daily check for updates on US-Iran tensions',
+      scheduleType: 'cron',
+      cron: '0 9 * * *',
+      status: 'active',
+      createdByAgentId: 'assistant',
+      createdInSessionId: 'session-1',
+      createdAt: 1,
+    },
+  }
+
+  const duplicate = findDuplicateSchedule(schedules, {
+    agentId: 'assistant',
+    taskPrompt: 'Periodic update check for US-Iran tensions',
+    scheduleType: 'interval',
+    intervalMs: 86_400_000,
+    createdByAgentId: 'assistant',
+    createdInSessionId: 'session-1',
+  }, {
+    creatorScope: {
+      agentId: 'assistant',
+      sessionId: 'session-1',
+    },
+  })
+
+  assert.ok(duplicate)
+  assert.equal(duplicate?.id, 'daily1')
+})
+
+test('findEquivalentSchedules does not fuzzy-match across sessions', () => {
+  const schedules: Record<string, ScheduleLike> = {
+    daily1: {
+      id: 'daily1',
+      agentId: 'assistant',
+      taskPrompt: 'Daily check for updates on US-Iran tensions',
+      scheduleType: 'cron',
+      cron: '0 9 * * *',
+      status: 'active',
+      createdByAgentId: 'assistant',
+      createdInSessionId: 'session-1',
+      createdAt: 1,
+    },
+  }
+
+  const matches = findEquivalentSchedules(schedules, {
+    agentId: 'assistant',
+    taskPrompt: 'Periodic update check for US-Iran tensions',
+    scheduleType: 'interval',
+    intervalMs: 86_400_000,
+    createdByAgentId: 'assistant',
+    createdInSessionId: 'session-2',
+  }, {
+    creatorScope: {
+      agentId: 'assistant',
+      sessionId: 'session-2',
+    },
+  })
+
+  assert.deepEqual(matches, [])
+})

package/src/lib/schedule-dedupe.ts

@@ -1,3 +1,4 @@
+import { CronExpressionParser } from 'cron-parser'
 import type { ScheduleType } from '@/types'
 
 export type ScheduleLike = {
@@ -41,12 +42,49 @@ interface ScheduleSignature {
   id: string
   agentId: string
   taskPrompt: string
+  promptTokens: string[]
   scheduleType: ScheduleType
   cron: string
   intervalMs: number | null
   runAt: number | null
 }
 
+type ScheduleMatchKind = 'exact' | 'fuzzy'
+
+const PROMPT_STOPWORDS = new Set([
+  'a',
+  'an',
+  'and',
+  'any',
+  'at',
+  'back',
+  'by',
+  'check',
+  'for',
+  'from',
+  'if',
+  'in',
+  'into',
+  'me',
+  'my',
+  'of',
+  'on',
+  'once',
+  'please',
+  'remind',
+  'report',
+  'task',
+  'the',
+  'this',
+  'to',
+  'up',
+  'update',
+  'updates',
+  'with',
+])
+
+const ONCE_MATCH_WINDOW_MS = 15 * 60 * 1000
+
 function normalizeString(value: unknown): string {
   return typeof value === 'string' ? value.trim() : ''
 }
@@ -57,6 +95,26 @@ function normalizePrompt(value: unknown): string {
   return text.replace(/\s+/g, ' ').trim().toLowerCase()
 }
 
+function normalizePromptToken(token: string): string {
+  let normalized = token
+  if (normalized.length > 4 && normalized.endsWith('ies')) normalized = `${normalized.slice(0, -3)}y`
+  else if (normalized.length > 5 && normalized.endsWith('ing')) normalized = normalized.slice(0, -3)
+  else if (normalized.length > 4 && normalized.endsWith('ed')) normalized = normalized.slice(0, -2)
+  else if (normalized.length > 3 && normalized.endsWith('s') && !normalized.endsWith('ss')) normalized = normalized.slice(0, -1)
+  return normalized
+}
+
+function tokenizePrompt(value: unknown): string[] {
+  const normalized = normalizePrompt(value).replace(/[^a-z0-9]+/g, ' ')
+  if (!normalized) return []
+  return normalized
+    .split(' ')
+    .map((token) => normalizePromptToken(token.trim()))
+    .filter((token) => token.length > 0)
+    .filter((token) => token.length > 2 || ['ai', 'uk', 'us', 'eu'].includes(token))
+    .filter((token) => !PROMPT_STOPWORDS.has(token))
+}
+
 function normalizeCron(value: unknown): string {
   const cron = normalizeString(value)
   if (!cron) return ''
@@ -84,6 +142,7 @@ function toSignature(raw: ScheduleLike | ScheduleDuplicateCandidate): ScheduleSi
     id: normalizeString(raw.id),
     agentId: normalizeString(raw.agentId),
     taskPrompt: normalizePrompt(raw.taskPrompt),
+    promptTokens: tokenizePrompt(raw.taskPrompt),
     scheduleType: normalizeScheduleType(raw.scheduleType),
     cron: normalizeCron(raw.cron),
     intervalMs: normalizePositiveInt(raw.intervalMs),
@@ -116,6 +175,85 @@ function sameCadence(a: ScheduleSignature, b: ScheduleSignature): boolean {
   return false
 }
 
+function tryResolveCronIntervalMs(cron: string): number | null {
+  if (!cron) return null
+  try {
+    const interval = CronExpressionParser.parse(cron, {
+      currentDate: new Date('2026-01-01T00:00:00.000Z'),
+    })
+    const first = interval.next().getTime()
+    const second = interval.next().getTime()
+    const diff = second - first
+    return diff > 0 ? diff : null
+  } catch {
+    return null
+  }
+}
+
+function cadenceFamilyFromMs(intervalMs: number | null): string {
+  if (intervalMs == null || intervalMs <= 0) return ''
+
+  const families: Array<{ label: string; ms: number; toleranceMs: number }> = [
+    { label: '15m', ms: 15 * 60 * 1000, toleranceMs: 60 * 1000 },
+    { label: '30m', ms: 30 * 60 * 1000, toleranceMs: 2 * 60 * 1000 },
+    { label: 'hourly', ms: 60 * 60 * 1000, toleranceMs: 5 * 60 * 1000 },
+    { label: '6h', ms: 6 * 60 * 60 * 1000, toleranceMs: 15 * 60 * 1000 },
+    { label: '12h', ms: 12 * 60 * 60 * 1000, toleranceMs: 30 * 60 * 1000 },
+    { label: 'daily', ms: 24 * 60 * 60 * 1000, toleranceMs: 60 * 60 * 1000 },
+    { label: 'weekly', ms: 7 * 24 * 60 * 60 * 1000, toleranceMs: 2 * 60 * 60 * 1000 },
+  ]
+
+  for (const family of families) {
+    if (Math.abs(intervalMs - family.ms) <= family.toleranceMs) return family.label
+  }
+
+  return `interval:${Math.round(intervalMs / 60_000)}m`
+}
+
+function cadenceFamily(signature: ScheduleSignature): string {
+  if (signature.scheduleType === 'once') return signature.runAt != null ? 'once' : ''
+  if (signature.scheduleType === 'interval') return cadenceFamilyFromMs(signature.intervalMs)
+  if (signature.scheduleType === 'cron') return cadenceFamilyFromMs(tryResolveCronIntervalMs(signature.cron))
+  return ''
+}
+
+function sameCadenceFamily(a: ScheduleSignature, b: ScheduleSignature): boolean {
+  if (sameCadence(a, b)) return true
+  if (a.scheduleType === 'once' && b.scheduleType === 'once') {
+    if (a.runAt == null || b.runAt == null) return false
+    return Math.abs(a.runAt - b.runAt) <= ONCE_MATCH_WINDOW_MS
+  }
+  if (a.scheduleType === 'once' || b.scheduleType === 'once') return false
+  const aFamily = cadenceFamily(a)
+  const bFamily = cadenceFamily(b)
+  return aFamily !== '' && aFamily === bFamily
+}
+
+function countTokenOverlap(a: string[], b: string[]): number {
+  if (!a.length || !b.length) return 0
+  const smaller = a.length <= b.length ? a : b
+  const largerSet = new Set(a.length <= b.length ? b : a)
+  let overlap = 0
+  for (const token of new Set(smaller)) {
+    if (largerSet.has(token)) overlap += 1
+  }
+  return overlap
+}
+
+function hasFuzzyPromptMatch(a: ScheduleSignature, b: ScheduleSignature): boolean {
+  if (!a.promptTokens.length || !b.promptTokens.length) return false
+  const uniqueA = [...new Set(a.promptTokens)]
+  const uniqueB = [...new Set(b.promptTokens)]
+  const overlap = countTokenOverlap(uniqueA, uniqueB)
+  if (overlap === 0) return false
+  const smallerSize = Math.min(uniqueA.length, uniqueB.length)
+  const largerSize = Math.max(uniqueA.length, uniqueB.length)
+  const coverage = overlap / smallerSize
+  const jaccard = overlap / new Set([...uniqueA, ...uniqueB]).size
+  if (smallerSize <= 2) return overlap === smallerSize
+  return overlap >= 2 && coverage >= 0.67 && (jaccard >= 0.5 || overlap >= Math.max(2, largerSize - 1))
+}
+
 function isEligibleStatus(status: unknown, includeStatuses: Set<string>): boolean {
   const normalized = normalizeString(status).toLowerCase() || 'active'
   return includeStatuses.has(normalized)
@@ -149,26 +287,45 @@ export function findDuplicateSchedule(
   candidateRaw: ScheduleDuplicateCandidate,
   opts: FindDuplicateScheduleOptions = {},
 ): ScheduleLike | null {
+  return findEquivalentSchedules(schedules, candidateRaw, opts)[0] || null
+}
+
+export function findEquivalentSchedules(
+  schedules: Record<string, ScheduleLike>,
+  candidateRaw: ScheduleDuplicateCandidate,
+  opts: FindDuplicateScheduleOptions = {},
+): ScheduleLike[] {
   const candidate = toSignature(candidateRaw)
-  if (!candidate.agentId) return null
-  if (!candidate.taskPrompt) return null
+  if (!candidate.agentId) return []
+  if (!candidate.taskPrompt) return []
 
   const ignoreId = normalizeString(opts.ignoreId || candidate.id)
   const statuses = new Set((opts.includeStatuses?.length ? opts.includeStatuses : ['active', 'paused']).map((s) => s.toLowerCase()))
+  const scopeSessionId = normalizeString(opts.creatorScope?.sessionId)
 
   const matches = Object.values(schedules)
     .filter((existing) => existing && typeof existing === 'object')
-    .filter((existing) => {
+    .map((existing) => {
       const signature = toSignature(existing)
-      if (!signature.id) return false
-      if (ignoreId && signature.id === ignoreId) return false
-      if (!isEligibleStatus(existing.status, statuses)) return false
-      if (!matchesCreatorScope(existing, opts.creatorScope || null)) return false
-      if (signature.agentId !== candidate.agentId) return false
-      if (signature.taskPrompt !== candidate.taskPrompt) return false
-      return sameCadence(signature, candidate)
+      if (!signature.id) return null
+      if (ignoreId && signature.id === ignoreId) return null
+      if (!isEligibleStatus(existing.status, statuses)) return null
+      if (!matchesCreatorScope(existing, opts.creatorScope || null)) return null
+      if (signature.agentId !== candidate.agentId) return null
+      const exact = signature.taskPrompt === candidate.taskPrompt && sameCadence(signature, candidate)
+      if (exact) return { existing, kind: 'exact' as const }
+      const fuzzy = Boolean(scopeSessionId)
+        && hasFuzzyPromptMatch(signature, candidate)
+        && sameCadenceFamily(signature, candidate)
+      if (!fuzzy) return null
+      return { existing, kind: 'fuzzy' as const }
+    })
+    .filter((entry): entry is { existing: ScheduleLike; kind: ScheduleMatchKind } => Boolean(entry))
+    .sort((a, b) => {
+      if (a.kind !== b.kind) return a.kind === 'exact' ? -1 : 1
+      return compareUpdatedDesc(a.existing, b.existing)
     })
-    .sort(compareUpdatedDesc)
+    .map((entry) => entry.existing)
 
-  return matches[0] || null
+  return matches
 }

package/src/lib/schedule-origin.test.ts

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import {
+  isAgentCreatedSchedule,
+  isUserCreatedSchedule,
+  shouldAutoDeleteScheduleAfterTerminalRun,
+} from './schedule-origin'
+
+test('recognizes agent-created schedules', () => {
+  assert.equal(isAgentCreatedSchedule({ scheduleType: 'interval', createdByAgentId: 'molly-2' }), true)
+  assert.equal(isUserCreatedSchedule({ scheduleType: 'interval', createdByAgentId: 'molly-2' }), false)
+})
+
+test('recognizes manual schedules and only auto-deletes agent-created one-offs', () => {
+  assert.equal(isUserCreatedSchedule({ scheduleType: 'once', createdByAgentId: null }), true)
+  assert.equal(shouldAutoDeleteScheduleAfterTerminalRun({ scheduleType: 'once', createdByAgentId: null }), false)
+  assert.equal(shouldAutoDeleteScheduleAfterTerminalRun({ scheduleType: 'once', createdByAgentId: 'molly-2' }), true)
+  assert.equal(shouldAutoDeleteScheduleAfterTerminalRun({ scheduleType: 'interval', createdByAgentId: 'molly-2' }), false)
+})

package/src/lib/schedule-origin.ts

@@ -0,0 +1,15 @@
+import type { Schedule } from '@/types'
+
+type ScheduleOriginShape = Pick<Schedule, 'scheduleType' | 'createdByAgentId'>
+
+export function isAgentCreatedSchedule(schedule: ScheduleOriginShape | null | undefined): boolean {
+  return Boolean(typeof schedule?.createdByAgentId === 'string' && schedule.createdByAgentId.trim())
+}
+
+export function isUserCreatedSchedule(schedule: ScheduleOriginShape | null | undefined): boolean {
+  return !isAgentCreatedSchedule(schedule)
+}
+
+export function shouldAutoDeleteScheduleAfterTerminalRun(schedule: ScheduleOriginShape | null | undefined): boolean {
+  return Boolean(schedule?.scheduleType === 'once' && isAgentCreatedSchedule(schedule))
+}

package/src/lib/server/__fixtures__/fake-mcp-stdio-server.mjs

@@ -0,0 +1,27 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { z } from 'zod'
+
+const server = new McpServer({
+  name: 'swarmclaw-fake-mcp',
+  version: '1.0.0',
+})
+
+server.registerTool('ping', {
+  description: 'Returns pong for smoke tests',
+  inputSchema: {},
+}, async () => ({
+  content: [{ type: 'text', text: 'pong' }],
+}))
+
+server.registerTool('echo', {
+  description: 'Echoes a caller-provided message',
+  inputSchema: {
+    message: z.string(),
+  },
+}, async ({ message }) => ({
+  content: [{ type: 'text', text: `echo: ${message}` }],
+}))
+
+const transport = new StdioServerTransport()
+await server.connect(transport)

package/src/lib/server/agent-availability.ts

@@ -0,0 +1,16 @@
+import type { Agent } from '@/types'
+
+export function isAgentDisabled(agent: Pick<Agent, 'disabled'> | null | undefined): boolean {
+  return agent?.disabled === true
+}
+
+export function buildAgentDisabledMessage(
+  agent: Pick<Agent, 'name'> | null | undefined,
+  action?: string,
+): string {
+  const name = typeof agent?.name === 'string' && agent.name.trim()
+    ? agent.name.trim()
+    : 'This agent'
+  if (action) return `${name} is disabled and cannot ${action}. Re-enable it to continue.`
+  return `${name} is disabled. Re-enable it to continue.`
+}

package/src/lib/server/agent-runtime-config.ts

@@ -6,6 +6,7 @@ import type {
   ProviderType,
 } from '@/types'
 import { deriveOpenClawWsUrl, normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
+import { getProvider } from '@/lib/providers'
 import { loadGatewayProfiles } from './storage'
 import { isProviderCoolingDown } from './provider-health'
 
@@ -75,6 +76,8 @@ function normalizeGatewayDeployment(
     useCase: normalizeText(deployment.useCase) as DeploymentConfig['useCase'],
     exposure: normalizeText(deployment.exposure) as DeploymentConfig['exposure'],
     managedBy: normalizeText(deployment.managedBy) as DeploymentConfig['managedBy'],
+    localInstanceId: normalizeText(deployment.localInstanceId),
+    localPort: normalizeNullableNumber(deployment.localPort),
     targetHost: normalizeText(deployment.targetHost),
     sshHost: normalizeText(deployment.sshHost),
     sshUser: normalizeText(deployment.sshUser),
@@ -247,6 +250,12 @@ function dedupeCredentialIds(primary: string | null | undefined, candidates: str
   return result
 }
 
+function resolveProviderDefaultEndpoint(provider: string): string | null {
+  const info = getProvider(provider)
+  if (!info?.defaultEndpoint) return null
+  return normalizeProviderEndpoint(provider, info.defaultEndpoint) || info.defaultEndpoint.replace(/\/+$/, '')
+}
+
 function buildRouteFromSeed(
   seed: RouteSeed,
   gatewayProfiles: GatewayProfile[],
@@ -267,10 +276,9 @@ function buildRouteFromSeed(
   const gatewayProfileId = gatewayProfile?.id ?? seed.gatewayProfileId ?? agentGatewayProfileId ?? null
 
   const providerFromGateway = gatewayProfile?.provider === 'openclaw' ? 'openclaw' : provider
-  const apiEndpoint = normalizeProviderEndpoint(
-    providerFromGateway,
-    seed.apiEndpoint ?? gatewayProfile?.endpoint ?? null,
-  )
+  const explicitEndpoint = seed.apiEndpoint ?? gatewayProfile?.endpoint ?? null
+  const apiEndpoint = normalizeProviderEndpoint(providerFromGateway, explicitEndpoint)
+    ?? resolveProviderDefaultEndpoint(providerFromGateway)
   const model = (seed.model || '').trim() || (providerFromGateway === 'openclaw' ? DEFAULT_OPENCLAW_MODEL : '')
   if (!providerFromGateway || !model) return null
 

package/src/lib/server/agent-thread-session.test.ts

@@ -56,6 +56,9 @@ describe('ensureAgentThreadSession', () => {
           fallbackCredentialIds: [],
           heartbeatEnabled: true,
           heartbeatIntervalSec: 600,
+          memoryScopeMode: 'agent',
+          memoryTierPreference: 'blended',
+          projectId: 'proj-1',
           createdAt: now,
           updatedAt: now,
           plugins: ['memory', 'web_search'],
@@ -80,6 +83,54 @@ describe('ensureAgentThreadSession', () => {
     assert.equal(output.session.shortcutForAgentId, 'molly')
     assert.equal(output.session.agentId, 'molly')
     assert.equal(output.session.heartbeatEnabled, true)
+    assert.equal(output.session.memoryScopeMode, 'agent')
+    assert.equal(output.session.memoryTierPreference, 'blended')
+    assert.equal(output.session.projectId, 'proj-1')
     assert.deepEqual(output.session.plugins, ['memory', 'web_search'])
   })
+
+  it('does not create a new shortcut chat when the agent is disabled', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const storage = storageMod.default || storageMod['module.exports'] || storageMod
+      const helperMod = await import('./src/lib/server/agent-thread-session.ts')
+      const ensureAgentThreadSession = helperMod.ensureAgentThreadSession
+        || helperMod.default?.ensureAgentThreadSession
+        || helperMod['module.exports']?.ensureAgentThreadSession
+
+      const now = Date.now()
+      storage.saveAgents({
+        molly: {
+          id: 'molly',
+          name: 'Molly',
+          description: 'Temporarily disabled helper',
+          provider: 'openai',
+          model: 'gpt-test',
+          credentialId: null,
+          apiEndpoint: null,
+          fallbackCredentialIds: [],
+          disabled: true,
+          heartbeatEnabled: true,
+          heartbeatIntervalSec: 600,
+          createdAt: now,
+          updatedAt: now,
+          plugins: ['memory'],
+        },
+      })
+
+      const session = ensureAgentThreadSession('molly')
+      const agents = storage.loadAgents()
+      const sessions = storage.loadSessions()
+
+      console.log(JSON.stringify({
+        sessionId: session?.id || null,
+        threadSessionId: agents.molly?.threadSessionId || null,
+        sessionCount: Object.keys(sessions).length,
+      }))
+    `)
+
+    assert.equal(output.sessionId, null)
+    assert.equal(output.threadSessionId, null)
+    assert.equal(output.sessionCount, 0)
+  })
 })

package/src/lib/server/agent-thread-session.ts

@@ -1,6 +1,7 @@
 import { genId } from '@/lib/id'
 import type { Agent, Session } from '@/types'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from './agent-runtime-config'
+import { isAgentDisabled } from './agent-availability'
 import { WORKSPACE_DIR } from './data-dir'
 import { loadAgents, loadSessions, saveAgents, saveSessions } from './storage'
 
@@ -44,6 +45,9 @@ function buildThreadSession(agent: Agent, sessionId: string, user: string, creat
     heartbeatEnabled: agent.heartbeatEnabled || false,
     heartbeatIntervalSec: agent.heartbeatIntervalSec || null,
     heartbeatTarget: existing?.heartbeatTarget || null,
+    memoryScopeMode: agent.memoryScopeMode || null,
+    memoryTierPreference: agent.memoryTierPreference || null,
+    projectId: agent.projectId || existing?.projectId || null,
     sessionResetMode: existing?.sessionResetMode || null,
     sessionIdleTimeoutSec: existing?.sessionIdleTimeoutSec || null,
     sessionMaxAgeSec: existing?.sessionMaxAgeSec || null,
@@ -95,6 +99,7 @@ export function ensureAgentThreadSession(agentId: string, user = 'default'): Ses
 
   const sessions = loadSessions()
   const now = Date.now()
+  const disabled = isAgentDisabled(agent)
 
   const existingId = typeof agent.threadSessionId === 'string' ? agent.threadSessionId : ''
   if (existingId && sessions[existingId]) {
@@ -119,6 +124,8 @@ export function ensureAgentThreadSession(agentId: string, user = 'default'): Ses
     return session
   }
 
+  if (disabled) return null
+
   const sessionId = `agent-chat-${agentId}-${genId()}`
   const session = buildThreadSession(agent, sessionId, user, now)
   sessions[sessionId] = session