@swarmclawai/swarmclaw 0.7.8 → 0.8.0

package/src/lib/server/memory-policy.test.ts

@@ -0,0 +1,43 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  inferAutomaticMemoryCategory,
+  normalizeMemoryCategory,
+  shouldAutoCaptureMemory,
+  shouldInjectMemoryContext,
+} from './memory-policy'
+
+test('normalizeMemoryCategory maps flat categories into hierarchical buckets', () => {
+  assert.equal(normalizeMemoryCategory('preference', 'User prefers terse replies'), 'identity/preferences')
+  assert.equal(normalizeMemoryCategory('decision', 'Ship the Docker path'), 'projects/decisions')
+  assert.equal(normalizeMemoryCategory('error', 'Root cause found'), 'execution/errors')
+  assert.equal(normalizeMemoryCategory('project', 'Repo setup'), 'projects/context')
+})
+
+test('shouldInjectMemoryContext skips low-signal greetings and acknowledgements', () => {
+  assert.equal(shouldInjectMemoryContext('thanks'), false)
+  assert.equal(shouldInjectMemoryContext('hello'), false)
+  assert.equal(shouldInjectMemoryContext('Remember this for later'), false)
+  assert.equal(shouldInjectMemoryContext('Compare the current deployment plan with what we decided yesterday'), true)
+})
+
+test('shouldAutoCaptureMemory filters noisy turns', () => {
+  assert.equal(shouldAutoCaptureMemory({ message: 'thanks', response: 'Happy to help with that.', source: 'chat' }), false)
+  assert.equal(shouldAutoCaptureMemory({ message: 'Please save this to memory', response: 'Stored memory "note".', source: 'chat' }), false)
+  assert.equal(shouldAutoCaptureMemory({
+    message: 'We decided to use the shared staging environment and keep the worker count at 2 for now.',
+    response: 'Decision captured: shared staging, worker count 2, and we will revisit after load testing next week.',
+    source: 'chat',
+  }), true)
+})
+
+test('inferAutomaticMemoryCategory picks a stable automatic bucket', () => {
+  assert.equal(
+    inferAutomaticMemoryCategory('The user prefers direct status updates.', 'I will keep future updates terse and direct.'),
+    'identity/preferences',
+  )
+  assert.equal(
+    inferAutomaticMemoryCategory('We decided to ship the GitHub import first.', 'Decision locked for the next milestone.'),
+    'projects/decisions',
+  )
+})

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

@@ -0,0 +1,132 @@
+import type { MemoryEntry } from '@/types'
+
+const ACK_RE = /^(?:ok(?:ay)?|cool|nice|got it|makes sense|thanks|thank you|thx|roger|copy|sounds good|sgtm|yep|yup|y|nope?|nah|kk|done)[.! ]*$/i
+const GREETING_RE = /^(?:hi|hello|hey|yo|morning|good morning|good afternoon|good evening)[.! ]*$/i
+const MEMORY_META_RE = /\b(?:remember|memory|memorize|store this|save this|forget)\b/i
+const LOW_SIGNAL_RESPONSE_RE = /^(?:HEARTBEAT_OK|NO_MESSAGE)\b/i
+
+function normalizeWhitespace(value: string): string {
+  return value.replace(/\s+/g, ' ').trim()
+}
+
+function lower(value: string | null | undefined): string {
+  return normalizeWhitespace(value || '').toLowerCase()
+}
+
+export function shouldInjectMemoryContext(message: string): boolean {
+  const trimmed = normalizeWhitespace(message)
+  if (!trimmed) return false
+  if (trimmed.length < 16 && (ACK_RE.test(trimmed) || GREETING_RE.test(trimmed))) return false
+  if (trimmed.length < 24 && MEMORY_META_RE.test(trimmed)) return false
+  return true
+}
+
+export function shouldAutoCaptureMemoryTurn(message: string, response: string): boolean {
+  const normalizedMessage = normalizeWhitespace(message)
+  const normalizedResponse = normalizeWhitespace(response)
+  if (normalizedMessage.length < 20 || normalizedResponse.length < 40) return false
+  if (ACK_RE.test(normalizedMessage) || GREETING_RE.test(normalizedMessage)) return false
+  if (LOW_SIGNAL_RESPONSE_RE.test(normalizedResponse)) return false
+  if (MEMORY_META_RE.test(normalizedMessage) && normalizedMessage.length < 120) return false
+  if (/^(?:sorry|i can(?:not|'t)|unable to|i do not have|i don't have)\b/i.test(normalizedResponse)) return false
+  return true
+}
+
+export function shouldAutoCaptureMemory(
+  input: { message?: string | null; response?: string | null } | string,
+  response?: string,
+): boolean {
+  if (typeof input === 'string') {
+    return shouldAutoCaptureMemoryTurn(input, response || '')
+  }
+  return shouldAutoCaptureMemoryTurn(input.message || '', input.response || '')
+}
+
+export function normalizeMemoryCategory(
+  input: string | null | undefined,
+  title: string | null | undefined,
+  content: string | null | undefined,
+): string {
+  const explicit = lower(input)
+  const sample = `${lower(title)}\n${lower(content)}`
+
+  const mapExplicit = (value: string): string | null => {
+    if (!value || value === 'note' || value === 'notes') return null
+    if (['preference', 'preferences', 'likes', 'dislikes'].includes(value)) return 'identity/preferences'
+    if (['identity', 'profile', 'persona'].includes(value)) return 'identity/profile'
+    if (['relationship', 'relationships', 'people'].includes(value)) return 'identity/relationships'
+    if (['decision', 'decisions', 'choice'].includes(value)) return 'projects/decisions'
+    if (['learning', 'learnings', 'lesson', 'lessons'].includes(value)) return 'projects/learnings'
+    if (['project', 'projects', 'task', 'tasks'].includes(value)) return 'projects/context'
+    if (['error', 'errors', 'incident', 'incidents', 'failure', 'failures'].includes(value)) return 'execution/errors'
+    if (['breadcrumb', 'execution', 'run', 'runs'].includes(value)) return 'operations/execution'
+    if (['fact', 'facts', 'knowledge', 'reference'].includes(value)) return 'knowledge/facts'
+    if (['working', 'scratch', 'draft'].includes(value)) return 'working/scratch'
+    if (value.includes('/')) return value
+    return value
+  }
+
+  const explicitMapped = mapExplicit(explicit)
+  if (explicitMapped) return explicitMapped
+
+  if (/\b(?:prefer(?:s|ence)?|likes?|dislikes?|favorite|timezone|pronouns|call me)\b/.test(sample)) {
+    return 'identity/preferences'
+  }
+  if (/\b(?:wife|husband|partner|friend|manager|teammate|client|customer|relationship)\b/.test(sample)) {
+    return 'identity/relationships'
+  }
+  if (/\b(?:decided|decision|approved|picked|selected|going with|will use)\b/.test(sample)) {
+    return 'projects/decisions'
+  }
+  if (/\b(?:learned|lesson|fixed|solved|root cause|failure|bug|regression|postmortem)\b/.test(sample)) {
+    return 'projects/learnings'
+  }
+  if (/\b(?:error|incident|stack trace|exception|crash)\b/.test(sample)) {
+    return 'execution/errors'
+  }
+  if (/\b(?:project|repo|repository|ticket|task|milestone|deadline|roadmap)\b/.test(sample)) {
+    return 'projects/context'
+  }
+  if (/\b(?:config|credential|endpoint|workspace|path|env var|environment|docker|sandbox)\b/.test(sample)) {
+    return 'operations/environment'
+  }
+  if (/\b(?:fact|documentation|reference|api|schema)\b/.test(sample)) {
+    return 'knowledge/facts'
+  }
+  return explicit && explicit !== 'note' && explicit !== 'notes' ? explicit : 'knowledge/facts'
+}
+
+export function buildMemoryDoctorReport(entries: MemoryEntry[], agentId?: string | null): string {
+  const topLevelCounts = new Map<string, number>()
+  let pinned = 0
+  let linked = 0
+  let shared = 0
+
+  for (const entry of entries) {
+    const category = normalizeMemoryCategory(entry.category, entry.title, entry.content)
+    const topLevel = category.split('/')[0] || 'other'
+    topLevelCounts.set(topLevel, (topLevelCounts.get(topLevel) || 0) + 1)
+    if (entry.pinned) pinned += 1
+    if (entry.linkedMemoryIds?.length) linked += 1
+    if (entry.sharedWith?.length) shared += 1
+  }
+
+  const categories = [...topLevelCounts.entries()]
+    .sort((left, right) => right[1] - left[1])
+    .map(([name, count]) => `- ${name}: ${count}`)
+
+  return [
+    'Memory Doctor',
+    `Agent scope: ${agentId || 'global/all'}`,
+    `Visible memories: ${entries.length}`,
+    `Pinned: ${pinned}`,
+    `Linked: ${linked}`,
+    `Shared: ${shared}`,
+    categories.length ? 'Top-level categories:' : 'Top-level categories: none',
+    ...(categories.length ? categories : []),
+  ].join('\n')
+}
+
+export function inferAutomaticMemoryCategory(message: string, response: string): string {
+  return normalizeMemoryCategory('note', message, response)
+}

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

@@ -0,0 +1,60 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import type { MemoryEntry } from '@/types'
+
+import { getMemoryTierForCategory, partitionMemoriesByTier, shouldHideFromDurableRecall } from './memory-tiers'
+
+test('getMemoryTierForCategory treats hierarchical execution and archive categories correctly', () => {
+  assert.equal(getMemoryTierForCategory('operations/execution'), 'working')
+  assert.equal(getMemoryTierForCategory('operations/execution/tool-run'), 'working')
+  assert.equal(getMemoryTierForCategory('working/scratch'), 'working')
+  assert.equal(getMemoryTierForCategory('session_archive'), 'archive')
+  assert.equal(getMemoryTierForCategory('projects/decisions'), 'durable')
+})
+
+test('partitionMemoriesByTier keeps auto execution notes out of durable memory', () => {
+  const partitioned = partitionMemoriesByTier([
+    { category: 'projects/decisions', metadata: undefined },
+    { category: 'operations/execution', metadata: undefined },
+    { category: 'session_archive', metadata: { tier: 'archive' } },
+  ])
+
+  assert.equal(partitioned.durable.length, 1)
+  assert.equal(partitioned.working.length, 1)
+  assert.equal(partitioned.archive.length, 1)
+})
+
+test('shouldHideFromDurableRecall hides superseded and auto-consolidated entries', () => {
+  const autoConsolidatedTitle: Pick<MemoryEntry, 'title' | 'metadata'> = {
+    title: '[auto-consolidated] Project Kodiak note',
+    metadata: undefined,
+  }
+  const autoConsolidatedOrigin: Pick<MemoryEntry, 'title' | 'metadata'> = {
+    title: 'Project Kodiak',
+    metadata: { origin: 'auto-consolidated' },
+  }
+  const supersededEntry: Pick<MemoryEntry, 'title' | 'metadata'> = {
+    title: 'Project Kodiak',
+    metadata: { supersededBy: 'abc123' },
+  }
+  const canonicalEntry: Pick<MemoryEntry, 'title' | 'metadata'> = {
+    title: 'Canonical project fact',
+    metadata: {},
+  }
+
+  assert.equal(shouldHideFromDurableRecall({
+    ...autoConsolidatedTitle,
+  }), true)
+
+  assert.equal(shouldHideFromDurableRecall({
+    ...autoConsolidatedOrigin,
+  }), true)
+
+  assert.equal(shouldHideFromDurableRecall({
+    ...supersededEntry,
+  }), true)
+
+  assert.equal(shouldHideFromDurableRecall({
+    ...canonicalEntry,
+  }), false)
+})

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

@@ -8,6 +8,10 @@ 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 (normalized.startsWith('session_archive/')) return 'archive'
+  if (normalized === 'operations/execution' || normalized.startsWith('operations/execution/')) return 'working'
+  if (normalized === 'working/scratch' || normalized.startsWith('working/')) return 'working'
+  if (normalized === 'execution' || normalized.startsWith('execution/')) return 'working'
   if (WORKING_CATEGORIES.has(normalized)) return 'working'
   return 'durable'
 }
@@ -38,3 +42,15 @@ export function partitionMemoriesByTier<T extends Pick<MemoryEntry, 'category' |
 export function isWorkingMemoryCategory(category: unknown): boolean {
   return getMemoryTierForCategory(category) === 'working'
 }
+
+export function shouldHideFromDurableRecall(
+  entry: Pick<MemoryEntry, 'title' | 'metadata'>,
+): boolean {
+  const metadata = entry.metadata || {}
+  const origin = typeof metadata.origin === 'string' ? metadata.origin.trim().toLowerCase() : ''
+  if (origin === 'auto-consolidated') return true
+  if (typeof metadata.supersededBy === 'string' && metadata.supersededBy.trim()) return true
+  if (typeof metadata.supersededAt === 'number' && Number.isFinite(metadata.supersededAt)) return true
+  const title = typeof entry.title === 'string' ? entry.title.trim().toLowerCase() : ''
+  return title.startsWith('[auto-consolidated]')
+}

package/src/lib/server/ollama-runtime.ts

@@ -0,0 +1,58 @@
+import { isOllamaCloudModel, stripOllamaCloudModelSuffix } from '@/lib/ollama-model'
+import { PROVIDER_DEFAULTS } from '@/lib/providers/provider-defaults'
+
+const OLLAMA_CLOUD_KEY_ENV_VARS = ['OLLAMA_API_KEY', 'OLLAMA_CLOUD_API_KEY'] as const
+
+function clean(value: string | null | undefined): string | null {
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  return trimmed || null
+}
+
+function isOllamaCloudEndpoint(endpoint: string | null | undefined): boolean {
+  const normalized = clean(endpoint)
+  if (!normalized) return false
+  return /^https?:\/\/(?:www\.)?ollama\.com(?:\/|$)/i.test(normalized)
+}
+
+function hasExplicitEndpoint(endpoint: string | null | undefined): boolean {
+  return clean(endpoint) !== null
+}
+
+export function resolveOllamaCloudApiKey(explicitApiKey?: string | null): string | null {
+  const explicit = clean(explicitApiKey)
+  if (explicit && explicit !== 'ollama') return explicit
+  for (const envName of OLLAMA_CLOUD_KEY_ENV_VARS) {
+    const candidate = clean(process.env[envName])
+    if (candidate) return candidate
+  }
+  return null
+}
+
+export function resolveOllamaRuntimeConfig(input: {
+  model?: string | null
+  apiKey?: string | null
+  apiEndpoint?: string | null
+}): {
+  model: string
+  useCloud: boolean
+  apiKey: string | null
+  endpoint: string
+} {
+  const rawModel = clean(input.model) || ''
+  const explicitApiKey = clean(input.apiKey)
+  const explicitEndpoint = clean(input.apiEndpoint)
+  const cloudApiKey = resolveOllamaCloudApiKey(explicitApiKey)
+  const useCloud = isOllamaCloudEndpoint(explicitEndpoint)
+    || (!hasExplicitEndpoint(explicitEndpoint) && (
+      Boolean(explicitApiKey && explicitApiKey !== 'ollama')
+      || (isOllamaCloudModel(rawModel) && Boolean(cloudApiKey))
+    ))
+
+  return {
+    model: useCloud ? (stripOllamaCloudModelSuffix(rawModel) || rawModel) : rawModel,
+    useCloud,
+    apiKey: useCloud ? cloudApiKey : explicitApiKey,
+    endpoint: useCloud ? PROVIDER_DEFAULTS.ollamaCloud : (explicitEndpoint || PROVIDER_DEFAULTS.ollama),
+  }
+}

package/src/lib/server/openclaw-deploy.test.ts

@@ -1,10 +1,20 @@
 import assert from 'node:assert/strict'
-import { test } from 'node:test'
+import { afterEach, test } from 'node:test'
 import {
   buildOpenClawDeployBundle,
+  getOpenClawLocalDeployCollectionStatus,
   getOpenClawLocalDeployStatus,
+  getOpenClawRemoteDeployCollectionStatus,
+  getOpenClawRemoteDeployStatus,
 } from './openclaw-deploy.ts'
 
+const GLOBAL_KEY = '__swarmclaw_openclaw_deploy__' as const
+const originalRuntimeState = (globalThis as typeof globalThis & { [GLOBAL_KEY]?: unknown })[GLOBAL_KEY]
+
+afterEach(() => {
+  ;(globalThis as typeof globalThis & { [GLOBAL_KEY]?: unknown })[GLOBAL_KEY] = originalRuntimeState
+})
+
 test('docker smart deploy bundle uses official image and provider-specific metadata', () => {
   const bundle = buildOpenClawDeployBundle({
     template: 'docker',
@@ -66,10 +76,108 @@ test('render bundle stays aligned with the official repo flow', () => {
 
 test('local deploy status exposes a sensible default endpoint before startup', () => {
   const status = getOpenClawLocalDeployStatus()
+  const collection = getOpenClawLocalDeployCollectionStatus()
 
+  assert.equal(status.id, 'local-default')
+  assert.equal(status.isPrimary, true)
   assert.equal(status.running, false)
   assert.equal(status.port, 18789)
   assert.equal(status.endpoint, 'http://127.0.0.1:18789/v1')
   assert.equal(status.wsUrl, 'ws://127.0.0.1:18789')
   assert.match(status.launchCommand, /npx openclaw gateway run/)
+  assert.equal(collection.primaryId, null)
+  assert.deepEqual(collection.items, [])
+})
+
+test('remote deploy status exposes a sensible default record before startup', () => {
+  const status = getOpenClawRemoteDeployStatus()
+  const collection = getOpenClawRemoteDeployCollectionStatus()
+
+  assert.equal(status.id, 'remote-default')
+  assert.equal(status.name, 'Remote OpenClaw')
+  assert.equal(status.isPrimary, true)
+  assert.equal(status.active, false)
+  assert.equal(status.status, 'idle')
+  assert.equal(status.target, null)
+  assert.equal(collection.primaryId, null)
+  assert.deepEqual(collection.items, [])
+})
+
+test('legacy singleton remote runtime state is migrated into the keyed remote collection', () => {
+  ;(globalThis as typeof globalThis & { [GLOBAL_KEY]?: unknown })[GLOBAL_KEY] = {
+    locals: {},
+    primaryLocalId: null,
+    remote: {
+      processId: null,
+      action: 'ssh-deploy',
+      target: 'gateway.example.com',
+      startedAt: 123,
+      lastError: null,
+      lastSummary: 'Deploying OpenClaw to gateway.example.com over SSH.',
+      lastCommandPreview: 'ssh root@gateway.example.com ...',
+      lastBackupPath: null,
+    },
+  }
+
+  const status = getOpenClawRemoteDeployStatus()
+  const collection = getOpenClawRemoteDeployCollectionStatus()
+
+  assert.equal(status.id, 'remote-default')
+  assert.equal(status.name, 'gateway.example.com')
+  assert.equal(status.target, 'gateway.example.com')
+  assert.equal(status.action, 'ssh-deploy')
+  assert.equal(status.lastSummary, 'Deploying OpenClaw to gateway.example.com over SSH.')
+  assert.equal(collection.primaryId, 'remote-default')
+  assert.equal(collection.items.length, 1)
+  assert.equal(collection.items[0]?.id, 'remote-default')
+})
+
+test('remote deploy collection preserves multiple remotes and targeted lookup', () => {
+  ;(globalThis as typeof globalThis & { [GLOBAL_KEY]?: unknown })[GLOBAL_KEY] = {
+    locals: {},
+    primaryLocalId: null,
+    remotes: {
+      'remote-alpha': {
+        name: 'alpha',
+        processId: null,
+        action: 'restart',
+        target: 'alpha.example.com',
+        startedAt: null,
+        createdAt: 10,
+        updatedAt: 20,
+        lastError: null,
+        lastSummary: 'Restarting OpenClaw on alpha.example.com.',
+        lastCommandPreview: 'ssh root@alpha.example.com docker compose restart',
+        lastBackupPath: null,
+      },
+      'remote-beta': {
+        name: 'beta',
+        processId: null,
+        action: 'upgrade',
+        target: 'beta.example.com',
+        startedAt: null,
+        createdAt: 30,
+        updatedAt: 40,
+        lastError: null,
+        lastSummary: 'Pulling openclaw:latest and recreating the OpenClaw stack on beta.example.com.',
+        lastCommandPreview: 'ssh root@beta.example.com docker compose up -d',
+        lastBackupPath: null,
+      },
+    },
+    primaryRemoteId: 'remote-alpha',
+  }
+
+  const collection = getOpenClawRemoteDeployCollectionStatus()
+  const primary = getOpenClawRemoteDeployStatus()
+  const beta = getOpenClawRemoteDeployStatus('remote-beta')
+
+  assert.equal(collection.primaryId, 'remote-alpha')
+  assert.equal(collection.items.length, 2)
+  assert.equal(collection.items[0]?.id, 'remote-beta')
+  assert.equal(collection.items[1]?.id, 'remote-alpha')
+  assert.equal(primary.id, 'remote-alpha')
+  assert.equal(primary.isPrimary, true)
+  assert.equal(beta.id, 'remote-beta')
+  assert.equal(beta.target, 'beta.example.com')
+  assert.equal(beta.isPrimary, false)
 })