@swarmclawai/swarmclaw 0.5.3 → 0.6.2

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

@@ -1,6 +1,7 @@
 import Database from 'better-sqlite3'
 import path from 'path'
 import fs from 'fs'
+import { createHash } from 'crypto'
 import { genId } from '@/lib/id'
 import type { MemoryEntry, FileReference, MemoryImage, MemoryReference } from '@/types'
 import { getEmbedding, cosineSimilarity, serializeEmbedding, deserializeEmbedding } from './embeddings'
@@ -32,6 +33,11 @@ export const MEMORY_FTS_STOP_WORDS = new Set([
   'you', 'your',
 ])
 
+function computeContentHash(category: string, content: string): string {
+  const normalized = `${category}|${content.toLowerCase().trim()}`
+  return createHash('sha256').update(normalized).digest('hex').slice(0, 16)
+}
+
 function shouldSkipSearchQuery(input: string): boolean {
   const text = String(input || '').toLowerCase().trim()
   if (!text) return true
@@ -329,6 +335,7 @@ function normalizeImage(rawImage: unknown, legacyImagePath?: string | null): Mem
 function initDb() {
   const db = new Database(DB_PATH)
   db.pragma('journal_mode = WAL')
+  db.pragma('busy_timeout = 5000')
 
   db.exec(`
     CREATE TABLE IF NOT EXISTS memories (
@@ -354,10 +361,22 @@ function initDb() {
     'linkedMemoryIds TEXT',
     '"references" TEXT',
     'image TEXT',
+    'pinned INTEGER DEFAULT 0',
+    'sharedWith TEXT',
+    'accessCount INTEGER DEFAULT 0',
+    'lastAccessedAt INTEGER DEFAULT 0',
+    'contentHash TEXT',
+    'reinforcementCount INTEGER DEFAULT 0',
   ]) {
     try { db.exec(`ALTER TABLE memories ADD COLUMN ${col}`) } catch { /* already exists */ }
   }
 
+  // Partial index for fast pinned-memory lookups
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(agentId, updatedAt DESC) WHERE pinned = 1`)
+
+  // Index for content hash dedup lookups
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(contentHash) WHERE contentHash IS NOT NULL`)
+
   // FTS5 virtual table for full-text search
   db.exec(`
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
@@ -441,6 +460,24 @@ function initDb() {
   })
   migrateLegacyRows()
 
+  // Backfill contentHash for existing rows that don't have one yet
+  const unhashed = (db.prepare(`SELECT COUNT(*) as cnt FROM memories WHERE contentHash IS NULL`).get() as { cnt: number }).cnt
+  if (unhashed > 0) {
+    const backfillRows = db.prepare(`SELECT id, category, content FROM memories WHERE contentHash IS NULL`).all() as Array<{ id: string; category: string; content: string }>
+    const backfillStmt = db.prepare(`UPDATE memories SET contentHash = ? WHERE id = ?`)
+    const BATCH = 500
+    for (let i = 0; i < backfillRows.length; i += BATCH) {
+      const batch = backfillRows.slice(i, i + BATCH)
+      const tx = db.transaction(() => {
+        for (const r of batch) {
+          backfillStmt.run(computeContentHash(r.category, r.content), r.id)
+        }
+      })
+      tx()
+    }
+    console.log(`[memory-db] Backfilled contentHash for ${backfillRows.length} memory row(s)`)
+  }
+
   // Fresh installs now start with an empty memory graph.
   // Durable memories are created only from actual user/agent interactions.
 
@@ -448,14 +485,14 @@ function initDb() {
     insert: db.prepare(`
       INSERT INTO memories (
         id, agentId, sessionId, category, title, content, metadata, embedding,
-        "references", filePaths, image, imagePath, linkedMemoryIds, createdAt, updatedAt
+        "references", filePaths, image, imagePath, linkedMemoryIds, pinned, sharedWith, contentHash, createdAt, updatedAt
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `),
     update: db.prepare(`
       UPDATE memories
       SET agentId=?, sessionId=?, category=?, title=?, content=?, metadata=?, embedding=?,
-          "references"=?, filePaths=?, image=?, imagePath=?, linkedMemoryIds=?, updatedAt=?
+          "references"=?, filePaths=?, image=?, imagePath=?, linkedMemoryIds=?, pinned=?, sharedWith=?, updatedAt=?
       WHERE id=?
     `),
     delete: db.prepare(`DELETE FROM memories WHERE id=?`),
@@ -467,6 +504,9 @@ function initDb() {
     },
     listAll: db.prepare(`SELECT * FROM memories ORDER BY updatedAt DESC LIMIT ?`),
     listByAgent: db.prepare(`SELECT * FROM memories WHERE agentId=? ORDER BY updatedAt DESC LIMIT ?`),
+    listByAgentOrShared: db.prepare(`SELECT * FROM memories WHERE agentId=? OR sharedWith LIKE ? ORDER BY updatedAt DESC LIMIT ?`),
+    listPinnedByAgent: db.prepare(`SELECT * FROM memories WHERE pinned = 1 AND agentId = ? ORDER BY updatedAt DESC LIMIT ?`),
+    listPinnedAll: db.prepare(`SELECT * FROM memories WHERE pinned = 1 ORDER BY updatedAt DESC LIMIT ?`),
     search: db.prepare(`
       SELECT m.* FROM memories m
       INNER JOIN memories_fts f ON m.rowid = f.rowid
@@ -479,6 +519,12 @@ function initDb() {
       WHERE memories_fts MATCH ? AND m.agentId = ?
       LIMIT ${MAX_FTS_RESULT_ROWS}
     `),
+    searchByAgentOrShared: db.prepare(`
+      SELECT m.* FROM memories m
+      INNER JOIN memories_fts f ON m.rowid = f.rowid
+      WHERE memories_fts MATCH ? AND (m.agentId = ? OR m.sharedWith LIKE ?)
+      LIMIT ${MAX_FTS_RESULT_ROWS}
+    `),
     // Remove a linked ID from all memories that reference it (cleanup on delete)
     findMemoriesLinkingTo: db.prepare(`SELECT * FROM memories WHERE linkedMemoryIds LIKE ?`),
     updateLinks: db.prepare(`UPDATE memories SET linkedMemoryIds = ?, updatedAt = ? WHERE id = ?`),
@@ -489,12 +535,31 @@ function initDb() {
       LIMIT 1
     `),
     allRowsByUpdated: db.prepare(`SELECT * FROM memories ORDER BY updatedAt DESC`),
+    countsByAgent: db.prepare(`SELECT COALESCE(agentId, '_global') AS agentKey, COUNT(*) AS cnt FROM memories GROUP BY agentKey`),
     exactDuplicateBySessionCategory: db.prepare(`
       SELECT * FROM memories
       WHERE sessionId = ? AND category = ? AND title = ? AND content = ?
       ORDER BY updatedAt DESC
       LIMIT 1
     `),
+    findByContentHash: db.prepare(`
+      SELECT * FROM memories
+      WHERE contentHash = ? AND agentId = ?
+      ORDER BY updatedAt DESC
+      LIMIT 1
+    `),
+    findByContentHashShared: db.prepare(`
+      SELECT * FROM memories
+      WHERE contentHash = ? AND agentId IS NULL
+      ORDER BY updatedAt DESC
+      LIMIT 1
+    `),
+    reinforceMemory: db.prepare(`
+      UPDATE memories SET reinforcementCount = reinforcementCount + 1, updatedAt = ? WHERE id = ?
+    `),
+    bumpAccessCount: db.prepare(`
+      UPDATE memories SET accessCount = accessCount + 1, lastAccessedAt = ? WHERE id = ?
+    `),
   }
 
   function rowToEntry(row: Record<string, unknown>): MemoryEntry {
@@ -517,6 +582,12 @@ function initDb() {
       image,
       imagePath: image?.path || undefined,
       linkedMemoryIds: linkedMemoryIds.length ? linkedMemoryIds : undefined,
+      pinned: row.pinned === 1,
+      sharedWith: parseJsonSafe<string[]>(row.sharedWith, []).length ? parseJsonSafe<string[]>(row.sharedWith, []) : undefined,
+      accessCount: typeof row.accessCount === 'number' ? row.accessCount : 0,
+      lastAccessedAt: typeof row.lastAccessedAt === 'number' ? row.lastAccessedAt : 0,
+      contentHash: typeof row.contentHash === 'string' ? row.contentHash : undefined,
+      reinforcementCount: typeof row.reinforcementCount === 'number' ? row.reinforcementCount : 0,
       createdAt: typeof row.createdAt === 'number' ? row.createdAt : Date.now(),
       updatedAt: typeof row.updatedAt === 'number' ? row.updatedAt : Date.now(),
     }
@@ -556,14 +627,27 @@ function initDb() {
       const category = data.category || 'note'
       const title = data.title || 'Untitled'
       const content = data.content || ''
+      const contentHash = computeContentHash(category, content)
+
+      // Content-hash dedup: if same content already exists for this agent, reinforce instead of duplicating
+      const agentId = data.agentId || null
+      const existingByHash = agentId
+        ? stmts.findByContentHash.get(contentHash, agentId) as Record<string, unknown> | undefined
+        : stmts.findByContentHashShared.get(contentHash) as Record<string, unknown> | undefined
+      if (existingByHash) {
+        stmts.reinforceMemory.run(now, existingByHash.id)
+        return rowToEntry({ ...existingByHash, reinforcementCount: ((existingByHash.reinforcementCount as number) || 0) + 1, updatedAt: now })
+      }
 
       // Guard against exact duplicate memory spam for the same session/category.
       if (sessionId) {
         const duplicate = stmts.exactDuplicateBySessionCategory.get(sessionId, category, title, content) as Record<string, unknown> | undefined
         if (duplicate) return rowToEntry(duplicate)
       }
+      const pinned = data.pinned ? 1 : 0
+      const sharedWith = Array.isArray(data.sharedWith) && data.sharedWith.length ? JSON.stringify(data.sharedWith) : null
       stmts.insert.run(
-        id, data.agentId || null, sessionId,
+        id, agentId, sessionId,
         category, title, content,
         data.metadata ? JSON.stringify(data.metadata) : null,
         null, // embedding computed async
@@ -572,6 +656,9 @@ function initDb() {
         image ? JSON.stringify(image) : null,
         image?.path || null,
         linkedMemoryIds.length ? JSON.stringify(linkedMemoryIds) : null,
+        pinned,
+        sharedWith,
+        contentHash,
         now, now,
       )
       // Compute embedding in background (fire-and-forget)
@@ -601,6 +688,10 @@ function initDb() {
         image,
         imagePath: image?.path || null,
         linkedMemoryIds,
+        accessCount: 0,
+        lastAccessedAt: 0,
+        contentHash,
+        reinforcementCount: 0,
         createdAt: now,
         updatedAt: now,
       }
@@ -617,6 +708,8 @@ function initDb() {
       const nextLinked = normalizeLinkedMemoryIds(merged.linkedMemoryIds, id)
       const prevLinked = normalizeLinkedMemoryIds(existingEntry.linkedMemoryIds, id)
       const now = Date.now()
+      const pinnedVal = merged.pinned ? 1 : 0
+      const sharedWithVal = Array.isArray(merged.sharedWith) && merged.sharedWith.length ? JSON.stringify(merged.sharedWith) : null
       stmts.update.run(
         merged.agentId || null, merged.sessionId || null,
         merged.category, merged.title, merged.content,
@@ -627,6 +720,8 @@ function initDb() {
         image ? JSON.stringify(image) : null,
         image?.path || null,
         nextLinked.length ? JSON.stringify(nextLinked) : null,
+        pinnedVal,
+        sharedWithVal,
         now, id,
       )
 
@@ -673,6 +768,10 @@ function initDb() {
     get(id: string): MemoryEntry | null {
       const row = stmts.getById.get(id) as Record<string, unknown> | undefined
       if (!row) return null
+      // Bump access count (non-blocking)
+      setTimeout(() => {
+        try { stmts.bumpAccessCount.run(Date.now(), id) } catch { /* best-effort */ }
+      }, 0)
       return rowToEntry(row)
     },
 
@@ -755,16 +854,17 @@ function initDb() {
     search(query: string, agentId?: string): MemoryEntry[] {
       if (shouldSkipSearchQuery(query)) return []
       const startedAt = Date.now()
-      // FTS keyword search
+      // FTS keyword search (includes memories shared with this agent)
       const ftsQuery = buildFtsQuery(query)
       const ftsResults: MemoryEntry[] = ftsQuery
         ? (agentId
-            ? stmts.searchByAgent.all(ftsQuery, agentId) as any[]
+            ? stmts.searchByAgentOrShared.all(ftsQuery, agentId, `%"${agentId}"%`) as any[]
             : stmts.search.all(ftsQuery) as any[]
           ).map(rowToEntry)
         : []
 
       // Attempt vector search (synchronous — uses cached embedding if available)
+      const vectorSimilarityScores = new Map<string, number>()
       let vectorResults: MemoryEntry[] = []
       try {
         const queryEmbedding = getEmbeddingSync(query)
@@ -783,13 +883,17 @@ function initDb() {
             .sort((a, b) => b.score - a.score)
             .slice(0, 20)
 
-          vectorResults = scored.map((s) => rowToEntry(s.row))
+          vectorResults = scored.map((s) => {
+            const entry = rowToEntry(s.row)
+            vectorSimilarityScores.set(entry.id, s.score)
+            return entry
+          })
         }
       } catch {
         // Vector search unavailable, use FTS only
       }
 
-      // Merge: deduplicate by id, FTS results first then vector-only
+      // Merge: deduplicate by id
       const seen = new Set<string>()
       const merged: MemoryEntry[] = []
       for (const entry of [...ftsResults, ...vectorResults]) {
@@ -798,7 +902,34 @@ function initDb() {
           merged.push(entry)
         }
       }
-      const out = merged.slice(0, MAX_MERGED_RESULTS)
+
+      // Apply salience scoring: similarity * recencyDecay * reinforcement * pinnedBoost
+      const now = Date.now()
+      const HALF_LIFE_DAYS = 30
+      const salienceScored = merged.map((entry) => {
+        const similarity = vectorSimilarityScores.get(entry.id) ?? 0.5
+        const daysSinceAccess = (now - (entry.lastAccessedAt || entry.updatedAt)) / 86_400_000
+        const recencyDecay = Math.exp(-0.693 * daysSinceAccess / HALF_LIFE_DAYS)
+        const reinforcement = Math.log((entry.reinforcementCount || 0) + 1) + 1
+        const pinnedBoost = entry.pinned ? 1.5 : 1.0
+        const salience = similarity * recencyDecay * reinforcement * pinnedBoost
+        return { entry, salience }
+      })
+      salienceScored.sort((a, b) => b.salience - a.salience)
+
+      const out = salienceScored.slice(0, MAX_MERGED_RESULTS).map((s) => s.entry)
+
+      // Bump access counts for returned results (non-blocking)
+      if (out.length) {
+        const returnedIds = out.map((e) => e.id)
+        setTimeout(() => {
+          try {
+            const ts = Date.now()
+            for (const mid of returnedIds) stmts.bumpAccessCount.run(ts, mid)
+          } catch { /* best-effort */ }
+        }, 0)
+      }
+
       const elapsed = Date.now() - startedAt
       if (elapsed > 1200) {
         console.warn(
@@ -838,11 +969,26 @@ function initDb() {
     list(agentId?: string, limit = 200): MemoryEntry[] {
       const safeLimit = Math.max(1, Math.min(500, Math.trunc(limit)))
       const rows = agentId
-        ? stmts.listByAgent.all(agentId, safeLimit) as any[]
+        ? stmts.listByAgentOrShared.all(agentId, `%"${agentId}"%`, safeLimit) as any[]
         : stmts.listAll.all(safeLimit) as any[]
       return rows.map(rowToEntry)
     },
 
+    listPinned(agentId?: string, limit = 20): MemoryEntry[] {
+      const safeLimit = Math.max(1, Math.min(100, Math.trunc(limit)))
+      const rows = agentId
+        ? stmts.listPinnedByAgent.all(agentId, safeLimit) as any[]
+        : stmts.listPinnedAll.all(safeLimit) as any[]
+      return rows.map(rowToEntry)
+    },
+
+    countsByAgent(): Record<string, number> {
+      const rows = stmts.countsByAgent.all() as { agentKey: string; cnt: number }[]
+      const result: Record<string, number> = {}
+      for (const row of rows) result[row.agentKey] = row.cnt
+      return result
+    },
+
     getByAgent(agentId: string, limit = 200): MemoryEntry[] {
       const safeLimit = Math.max(1, Math.min(500, Math.trunc(limit)))
       return (stmts.listByAgent.all(agentId, safeLimit) as any[]).map(rowToEntry)
@@ -924,9 +1070,32 @@ function initDb() {
       const pruneWorking = options.pruneWorking !== false
       const cutoff = Date.now() - Math.max(1, Math.min(24 * 365, Math.trunc(options.ttlHours || 24))) * 3600_000
 
+      // Hash-based dedup: group by contentHash + agentId, keep the one with highest reinforcementCount
+      if (dedupe && toDelete.size < deleteBudget) {
+        const hashGroups = new Map<string, MemoryEntry[]>()
+        for (const row of rows) {
+          if (!row.contentHash || toDelete.has(row.id)) continue
+          const groupKey = `${row.agentId || ''}|${row.contentHash}`
+          const group = hashGroups.get(groupKey)
+          if (group) group.push(row)
+          else hashGroups.set(groupKey, [row])
+        }
+        for (const group of hashGroups.values()) {
+          if (group.length <= 1) continue
+          group.sort((a, b) => (b.reinforcementCount || 0) - (a.reinforcementCount || 0))
+          for (let i = 1; i < group.length; i++) {
+            toDelete.add(group[i].id)
+            if (toDelete.size >= deleteBudget) break
+          }
+          if (toDelete.size >= deleteBudget) break
+        }
+      }
+
+      // Exact string-match dedup (legacy fallback for rows without contentHash)
       if (dedupe) {
         const seen = new Set<string>()
         for (const row of rows) {
+          if (toDelete.has(row.id)) continue
           const key = [
             row.agentId || '',
             row.sessionId || '',
@@ -1019,6 +1188,8 @@ export function addKnowledge(params: {
   title: string
   content: string
   tags?: string[]
+  scope?: 'global' | 'agent'
+  agentIds?: string[]
   createdByAgentId?: string | null
   createdBySessionId?: string | null
 }): MemoryEntry {
@@ -1031,6 +1202,8 @@ export function addKnowledge(params: {
     content: params.content,
     metadata: {
       tags: params.tags || [],
+      scope: params.scope || 'global',
+      agentIds: params.scope === 'agent' ? (params.agentIds || []) : [],
       createdByAgentId: params.createdByAgentId || null,
       createdBySessionId: params.createdBySessionId || null,
     },

package/src/lib/server/mime.ts

@@ -0,0 +1,51 @@
+export const MIME_TYPES: Record<string, string> = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mov': 'video/quicktime',
+  '.avi': 'video/x-msvideo',
+  '.mkv': 'video/x-matroska',
+  '.pdf': 'application/pdf',
+  '.json': 'application/json',
+  '.csv': 'text/csv',
+  '.txt': 'text/plain',
+  '.html': 'text/html',
+  '.xml': 'application/xml',
+  '.zip': 'application/zip',
+  '.tar': 'application/x-tar',
+  '.gz': 'application/gzip',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.xls': 'application/vnd.ms-excel',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+}
+
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico'])
+const VIDEO_EXTS = new Set(['.mp4', '.webm', '.mov', '.avi', '.mkv'])
+const AUDIO_EXTS = new Set(['.mp3', '.wav', '.ogg'])
+const DOCUMENT_EXTS = new Set(['.pdf', '.json', '.csv', '.txt', '.html', '.xml', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx'])
+const ARCHIVE_EXTS = new Set(['.zip', '.tar', '.gz'])
+
+export type FileCategory = 'image' | 'video' | 'audio' | 'document' | 'archive' | 'other'
+
+export function getFileCategory(ext: string): FileCategory {
+  const lower = ext.toLowerCase()
+  if (IMAGE_EXTS.has(lower)) return 'image'
+  if (VIDEO_EXTS.has(lower)) return 'video'
+  if (AUDIO_EXTS.has(lower)) return 'audio'
+  if (DOCUMENT_EXTS.has(lower)) return 'document'
+  if (ARCHIVE_EXTS.has(lower)) return 'archive'
+  return 'other'
+}

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

@@ -77,6 +77,7 @@ export class OpenClawGateway {
   private _connected = false
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null
   private reconnectDelay = 800
+  private consecutiveFailures = 0
   private shouldReconnect = false
   private wsUrl = ''
   private token: string | undefined
@@ -104,6 +105,7 @@ export class OpenClawGateway {
       this.ws = result.ws
       this._connected = true
       this.reconnectDelay = 800
+      this.consecutiveFailures = 0
       console.log('[openclaw-gateway] Connected to gateway')
 
       this.ws.on('message', (data) => {
@@ -149,12 +151,18 @@ export class OpenClawGateway {
 
   private scheduleReconnect() {
     if (this.reconnectTimer || !this.shouldReconnect) return
+    this.consecutiveFailures++
+    // After many failures, back off to 10 minutes to avoid hammering a down server
+    const maxDelay = this.consecutiveFailures >= 10 ? 600_000 : 15_000
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null
       if (!this.shouldReconnect) return
       this.doConnect().catch(() => {})
     }, this.reconnectDelay)
-    this.reconnectDelay = Math.min(this.reconnectDelay * 2, 15_000)
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, maxDelay)
+    if (this.consecutiveFailures === 1 || this.consecutiveFailures % 5 === 0) {
+      console.log(`[openclaw-gateway] ${this.consecutiveFailures} consecutive failure${this.consecutiveFailures > 1 ? 's' : ''}, next retry in ${Math.round(this.reconnectDelay / 1000)}s`)
+    }
   }
 
   private rejectAllPending(reason: string) {

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

@@ -11,6 +11,7 @@ import { buildChatModel } from './build-llm'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { notify } from './ws-hub'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
+import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { genId } from '@/lib/id'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 import type { Agent, TaskComment, MessageToolEvent } from '@/types'
@@ -351,6 +352,7 @@ export async function executeLangGraphOrchestrator(
   const settings = loadSettings()
   const promptParts: string[] = []
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
+  promptParts.push(buildCurrentDateTimePromptContext())
   if (orchestrator.soul) promptParts.push(orchestrator.soul)
   if (orchestrator.systemPrompt) promptParts.push(orchestrator.systemPrompt)
   // Inject dynamic skills

package/src/lib/server/orchestrator.ts

@@ -6,6 +6,7 @@ import {
 import { WORKSPACE_DIR } from './data-dir'
 import { loadRuntimeSettings, getLegacyOrchestratorMaxTurns } from './runtime-settings'
 import { getMemoryDb } from './memory-db'
+import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { getProvider } from '../providers'
 import type { Agent } from '@/types'
 
@@ -109,6 +110,7 @@ async function executeOrchestratorLegacy(
   const settings = loadSettings()
   const promptParts: string[] = []
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
+  promptParts.push(buildCurrentDateTimePromptContext())
   if (orchestrator.soul) promptParts.push(orchestrator.soul)
   if (orchestrator.systemPrompt) promptParts.push(orchestrator.systemPrompt)
   if (orchestrator.skillIds?.length) {
@@ -308,8 +310,8 @@ async function executeSubTask(
 
 export async function callProvider(
   agent: Agent,
-  systemPrompt: string,
-  history: { role: string; text: string }[],
+  systemPrompt?: string,
+  history: { role: string; text: string }[] = [],
 ): Promise<string> {
   const provider = getProvider(agent.provider)
   if (!provider) throw new Error(`Unknown provider: ${agent.provider}`)
@@ -346,6 +348,7 @@ export async function callProvider(
     session: mockSession,
     message: history[history.length - 1].text,
     apiKey,
+    systemPrompt,
     write: (data: string) => {
       // Parse SSE data to extract text
       if (data.startsWith('data: ')) {

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

@@ -7,9 +7,8 @@
 import { spawn } from 'child_process'
 import fs from 'fs'
 import path from 'path'
-import os from 'os'
 
-const UPLOAD_DIR = process.env.SWARMCLAW_UPLOAD_DIR || path.join(os.tmpdir(), 'swarmclaw-uploads')
+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'], {
@@ -47,7 +46,7 @@ child.stdout.on('data', (chunk) => {
             fs.writeFileSync(path.join(UPLOAD_DIR, filename), Buffer.from(block.data, 'base64'))
             newContent.push({
               type: 'text',
-              text: `Screenshot saved. Show it to the user with this markdown: ![Screenshot](/api/uploads/${filename})`,
+              text: `Screenshot saved to /api/uploads/${filename} — it is already displayed inline above (do not repeat it with markdown).`,
             })
             newContent.push(block) // keep image so Claude can see it
           } else {

package/src/lib/server/prompt-runtime-context.ts

@@ -0,0 +1,53 @@
+function resolveLocalTimezone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'
+  } catch {
+    return 'UTC'
+  }
+}
+
+function formatDateTimeInTimezone(date: Date, timezone: string): string | null {
+  try {
+    return new Intl.DateTimeFormat('en-US', {
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false,
+      timeZone: timezone,
+      timeZoneName: 'short',
+    }).format(date)
+  } catch {
+    return null
+  }
+}
+
+export function buildCurrentDateTimePromptContext(preferredTimezone?: string | null): string {
+  const now = new Date()
+  const utcIso = now.toISOString()
+  const utcFormatted = formatDateTimeInTimezone(now, 'UTC') || utcIso
+  const localTimezone = resolveLocalTimezone()
+  const requestedTimezone = (preferredTimezone || '').trim()
+  const chosenTimezone = requestedTimezone || localTimezone
+  const chosenFormatted = formatDateTimeInTimezone(now, chosenTimezone)
+
+  const lines = [
+    '## Runtime Date/Time Context',
+    `- Current timestamp (UTC): ${utcIso}`,
+    `- Current date/time (UTC): ${utcFormatted}`,
+  ]
+
+  if (chosenFormatted) {
+    lines.push(`- Current date/time (${chosenTimezone}): ${chosenFormatted}`)
+  } else if (requestedTimezone) {
+    lines.push(`- Requested timezone "${requestedTimezone}" could not be resolved. Use UTC time above.`)
+  }
+
+  lines.push('- Treat these as authoritative for terms like "today", "yesterday", "tomorrow", and "recent".')
+  lines.push('- For time-sensitive answers, use explicit dates (for example, "March 2, 2026").')
+
+  return lines.join('\n')
+}