@swarmclawai/swarmclaw 0.6.8 → 0.7.0

package/src/lib/server/session-tools/context-mgmt.ts

@@ -1,121 +1,103 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import { HumanMessage } from '@langchain/core/messages'
-import { loadSessions, saveSessions, loadCredentials, decryptKey } from '../storage'
+import { loadSessions, saveSessions } from '../storage'
 import { buildChatModel } from '../build-llm'
-import { getProvider } from '@/lib/providers'
 import type { ToolBuildContext } from './context'
+import type { Plugin, PluginHooks, Session } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
-export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  const tools: StructuredToolInterface[] = []
-  const { ctx, activeTools, resolveCurrentSession } = bctx
+interface ContextToolContext {
+  ctx?: { agentId?: string | null; sessionId?: string | null }
+  resolveCurrentSession?: () => Session | null
+}
 
-  if (activeTools.length > 0) {
-    tools.push(
-      tool(
-        async () => {
-          try {
-            const { getContextStatus } = await import('../context-manager')
-            const session = resolveCurrentSession()
-            if (!session) return 'Error: no current session context.'
-            const messages = session.messages || []
-            const systemPromptTokens = 2000
-            const status = getContextStatus(messages, systemPromptTokens, session.provider, session.model)
-            return JSON.stringify(status)
-          } catch (err: unknown) {
-            return `Error: ${err instanceof Error ? err.message : String(err)}`
-          }
-        },
-        {
-          name: 'context_status',
-          description: 'Check how much of my context window I\'ve used. Returns my token usage, the model\'s limit, percentage used, and whether I should compact.',
-          schema: z.object({}),
-        },
-      ),
-    )
+/**
+ * Core Context Management Execution Logic
+ */
+async function executeContextStatus(bctx: ContextToolContext) {
+  try {
+    const { getContextStatus } = await import('../context-manager')
+    const session = bctx.resolveCurrentSession?.()
+    if (!session) return 'Error: no current session context.'
+    const status = getContextStatus(session.messages || [], 2000, session.provider as string, session.model as string)
+    return JSON.stringify(status)
+  } catch (err: unknown) { return `Error: ${err instanceof Error ? err.message : String(err)}` }
+}
 
-    tools.push(
-      tool(
-        async ({ keepLastN }) => {
-          try {
-            const { summarizeAndCompact } = await import('../context-manager')
-            const session = resolveCurrentSession()
-            if (!session) return 'Error: no current session context.'
-            if (!ctx?.sessionId) return 'Error: no session id in context.'
-            const messages = session.messages || []
-            const keep = Math.max(2, Math.min(keepLastN || 10, messages.length))
+async function executeContextSummarize(args: { keepLastN?: number }, bctx: ContextToolContext) {
+  try {
+    const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+    const { summarizeAndCompact } = await import('../context-manager')
+    const session = bctx.resolveCurrentSession?.()
+    if (!session || !bctx.ctx?.sessionId) return 'Error: no session context.'
+    
+    const messages = session.messages || []
+    const keepLastN = normalized.keepLastN as number | undefined
+    const keep = Math.max(2, Math.min(keepLastN || 10, messages.length))
+    if (messages.length <= keep) return JSON.stringify({ status: 'no_action' })
 
-            if (messages.length <= keep) {
-              return JSON.stringify({ status: 'no_action', reason: 'Not enough messages to compact', messageCount: messages.length })
-            }
+    const generateSummary = async (prompt: string): Promise<string> => {
+      const llm = buildChatModel({ provider: session.provider, model: session.model, apiKey: null })
+      const res = await llm.invoke([new HumanMessage(prompt)])
+      return typeof res.content === 'string' ? res.content : ''
+    }
 
-            // Resolve API key for the session's provider
-            let apiKey: string | null = null
-            const providerInfo = getProvider(session.provider)
-            if ((providerInfo?.requiresApiKey || providerInfo?.optionalApiKey) && session.credentialId) {
-              try {
-                const creds = loadCredentials()
-                const cred = creds[session.credentialId]
-                if (cred) apiKey = decryptKey(cred.encryptedKey)
-              } catch { /* continue without key */ }
-            }
+    const result = await summarizeAndCompact({
+      messages, keepLastN: keep, agentId: bctx.ctx.agentId ?? null, sessionId: bctx.ctx.sessionId ?? '',
+      provider: session.provider, model: session.model, generateSummary
+    })
 
-            // Build LLM summarizer using the session's provider/model
-            const generateSummary = async (prompt: string): Promise<string> => {
-              const llm = buildChatModel({
-                provider: session.provider,
-                model: session.model,
-                apiKey,
-                apiEndpoint: session.apiEndpoint,
-              })
-              const response = await llm.invoke([new HumanMessage(prompt)])
-              if (typeof response.content === 'string') return response.content
-              if (Array.isArray(response.content)) {
-                return response.content
-                  .map((b: Record<string, unknown>) => (typeof b.text === 'string' ? b.text : ''))
-                  .join('')
-              }
-              return ''
-            }
+    const sessions = loadSessions()
+    if (sessions[bctx.ctx.sessionId]) {
+      sessions[bctx.ctx.sessionId].messages = result.messages
+      saveSessions(sessions)
+    }
+    return JSON.stringify({ status: 'compacted', remaining: result.messages.length })
+  } catch (err: unknown) { return `Error: ${err instanceof Error ? err.message : String(err)}` }
+}
 
-            const result = await summarizeAndCompact({
-              messages,
-              keepLastN: keep,
-              agentId: ctx?.agentId || session.agentId || null,
-              sessionId: ctx.sessionId,
-              provider: session.provider,
-              model: session.model,
-              generateSummary,
-            })
+/**
+ * Register as a Built-in Plugin
+ */
+const ContextPlugin: Plugin = {
+  name: 'Core Context',
+  description: 'Manage and optimize the agent conversation context window.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'context_status',
+      description: 'Check token usage and context window limits.',
+      parameters: { type: 'object', properties: {} },
+      execute: async (_args, context) => executeContextStatus({ resolveCurrentSession: () => context.session as unknown as Session })
+    },
+    {
+      name: 'context_summarize',
+      description: 'Compact conversation history to free up space.',
+      parameters: {
+        type: 'object',
+        properties: { keepLastN: { type: 'number' } }
+      },
+      execute: async (args, context) => executeContextSummarize(args as { keepLastN?: number }, { ctx: { sessionId: context.session.id, agentId: context.session.agentId ?? null }, resolveCurrentSession: () => context.session as unknown as Session })
+    }
+  ]
+}
 
-            const sessions = loadSessions()
-            const target = sessions[ctx.sessionId]
-            if (target) {
-              target.messages = result.messages
-              saveSessions(sessions)
-            }
+getPluginManager().registerBuiltin('context_mgmt', ContextPlugin)
 
-            return JSON.stringify({
-              status: 'compacted',
-              prunedCount: result.prunedCount,
-              memoriesStored: result.memoriesStored,
-              summaryAdded: result.summaryAdded,
-              remainingMessages: result.messages.length,
-            })
-          } catch (err: unknown) {
-            return `Error: ${err instanceof Error ? err.message : String(err)}`
-          }
-        },
-        {
-          name: 'context_summarize',
-          description: 'Compact my conversation history to free up context space. I\'ll save important decisions, facts, and results to memory, then replace older messages with a summary. I should check context_status first to see if this is needed.',
-          schema: z.object({
-            keepLastN: z.number().optional().describe('Number of recent messages to keep (default 10, min 2).'),
-          }),
-        },
-      ),
+/**
+ * Legacy Bridge
+ */
+export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  return [
+    tool(
+      async () => executeContextStatus(bctx),
+      { name: 'context_status', description: ContextPlugin.tools![0].description, schema: z.object({}).passthrough() }
+    ),
+    tool(
+      async (args) => executeContextSummarize(args as { keepLastN?: number }, bctx),
+      { name: 'context_summarize', description: ContextPlugin.tools![1].description, schema: z.object({}).passthrough() }
     )
-  }
-
-  return tools
+  ]
 }

package/src/lib/server/session-tools/crud.ts

@@ -15,6 +15,7 @@ import {
   loadWebhooks, saveWebhooks,
   loadSecrets, saveSecrets,
   loadSessions, saveSessions,
+  loadSettings,
   encryptKey,
   decryptKey,
 } from '../storage'
@@ -22,8 +23,10 @@ import { resolveScheduleName } from '@/lib/schedule-name'
 import { findDuplicateSchedule, type ScheduleLike } from '@/lib/schedule-dedupe'
 import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
 import { resolveTaskAgentFromDescription } from '@/lib/server/task-mention'
+import { normalizeTaskQualityGate } from '@/lib/server/task-quality-gate'
 import type { ToolBuildContext } from './context'
 import { safePath, findBinaryOnPath } from './context'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
 // ---------------------------------------------------------------------------
 // Document helpers
@@ -87,6 +90,41 @@ function trimDocumentContent(text: string): string {
   return normalized.slice(0, MAX_DOCUMENT_TEXT_CHARS)
 }
 
+function deriveTaskTitle(input: { title?: unknown; description?: unknown }): string {
+  const explicit = typeof input.title === 'string' ? input.title.replace(/\s+/g, ' ').trim() : ''
+  if (explicit && !/^untitled task$/i.test(explicit)) return explicit.slice(0, 120)
+
+  const description = typeof input.description === 'string'
+    ? input.description.replace(/\s+/g, ' ').trim()
+    : ''
+  if (!description) return ''
+
+  const firstSentence = description.split(/[.!?]\s+/)[0] || description
+  const compact = firstSentence
+    .replace(/^please\s+/i, '')
+    .replace(/^(create|make|build|implement|write)\s+/i, '')
+    .trim()
+  if (!compact) return ''
+  return compact.slice(0, 120)
+}
+
+const TASK_STATUS_VALUES = new Set([
+  'backlog',
+  'queued',
+  'running',
+  'completed',
+  'failed',
+  'archived',
+])
+
+function normalizeTaskStatusInput(status: unknown, prevStatus?: string): string | null {
+  if (typeof status !== 'string') return null
+  const normalized = status.trim().toLowerCase()
+  if (!TASK_STATUS_VALUES.has(normalized)) return null
+  if (normalized === 'running' && prevStatus !== 'running') return 'queued'
+  return normalized
+}
+
 // ---------------------------------------------------------------------------
 // RESOURCE_DEFAULTS
 // ---------------------------------------------------------------------------
@@ -107,7 +145,7 @@ const RESOURCE_DEFAULTS: Record<string, (parsed: any) => any> = {
     ...p,
   }),
   manage_tasks: (p) => ({
-    title: p.title || 'Untitled Task',
+    title: deriveTaskTitle(p) || 'Untitled Task',
     description: p.description || '',
     status: p.status || 'backlog',
     agentId: p.agentId || null,
@@ -218,9 +256,9 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
     let description = `Manage SwarmClaw ${res.label}. ${res.readOnly ? 'List and get only.' : 'List, get, create, update, or delete.'} Returns JSON.`
     if (toolKey === 'manage_tasks') {
       if (assignScope === 'self') {
-        description += `\n\nSet "agentId" to assign a task to yourself ("${ctx?.agentId || 'unknown'}") or leave it null. You can only assign tasks to yourself. Valid statuses: backlog, queued, running, completed, failed.`
+        description += `\n\nSet "agentId" to assign a task to yourself ("${ctx?.agentId || 'unknown'}") or leave it null. You can only assign tasks to yourself. Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.`
       } else {
-        description += `\n\nSet "agentId" to assign a task to an agent (including yourself: "${ctx?.agentId || 'unknown'}"). Valid statuses: backlog, queued, running, completed, failed.` + agentSummary
+        description += `\n\nSet "agentId" to assign a task to an agent (including yourself: "${ctx?.agentId || 'unknown'}"). Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.` + agentSummary
       }
     } else if (toolKey === 'manage_agents') {
       description += `\n\nAgents may self-edit their own soul. To update your soul, use action="update", id="${ctx?.agentId || 'your-agent-id'}", and include data with the "soul" field.`
@@ -236,7 +274,11 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
 
     tools.push(
       tool(
-        async ({ action, id, data }) => {
+        async (rawArgs) => {
+          const normalized = normalizeToolInputArgs((rawArgs ?? {}) as Record<string, unknown>)
+          const action = normalized.action as string | undefined
+          const id = normalized.id as string | undefined
+          const data = normalized.data as string | undefined
           const canAccessSecret = (secret: any): boolean => {
             if (!secret) return false
             if (secret.scope !== 'agent') return true
@@ -354,6 +396,20 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   agents,
                 )
               }
+              if (toolKey === 'manage_tasks') {
+                parsed.title = deriveTaskTitle(parsed)
+                if (!parsed.title || /^untitled task$/i.test(parsed.title)) {
+                  return 'Error: manage_tasks create requires a specific title or a meaningful description.'
+                }
+                parsed.status = normalizeTaskStatusInput(parsed.status) || 'backlog'
+                if (!parsed.cwd && cwd) parsed.cwd = cwd
+                if (Object.prototype.hasOwnProperty.call(parsed, 'qualityGate')) {
+                  const settings = loadSettings()
+                  parsed.qualityGate = parsed.qualityGate
+                    ? normalizeTaskQualityGate(parsed.qualityGate, settings)
+                    : null
+                }
+              }
               // Task dedup
               if (toolKey === 'manage_tasks') {
                 const fp = computeTaskFingerprint(parsed.title || 'Untitled Task', parsed.agentId || ctx?.agentId || '')
@@ -400,9 +456,10 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if (toolKey === 'manage_tasks' && entry.status === 'completed') {
                 const { formatValidationFailure, validateTaskCompletion } = await import('../task-validation')
                 const { ensureTaskCompletionReport } = await import('../task-reports')
+                const settings = loadSettings()
                 const report = ensureTaskCompletionReport(entry as any)
                 if (report?.relativePath) (entry as any).completionReportPath = report.relativePath
-                const validation = validateTaskCompletion(entry as any, { report })
+                const validation = validateTaskCompletion(entry as any, { report, settings })
                 ;(entry as any).validation = validation
                 if (!validation.ok) {
                   entry.status = 'failed'
@@ -431,6 +488,17 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if (!all[id]) return `Not found: ${res.label} "${id}"`
               const parsed = data ? JSON.parse(data) : {}
               const prevStatus = all[id]?.status
+              if (toolKey === 'manage_tasks' && Object.prototype.hasOwnProperty.call(parsed, 'status')) {
+                const normalized = normalizeTaskStatusInput(parsed.status, prevStatus)
+                if (normalized) parsed.status = normalized
+                else delete parsed.status
+              }
+              if (toolKey === 'manage_tasks' && Object.prototype.hasOwnProperty.call(parsed, 'qualityGate')) {
+                const settings = loadSettings()
+                parsed.qualityGate = parsed.qualityGate
+                  ? normalizeTaskQualityGate(parsed.qualityGate, settings)
+                  : null
+              }
               // Enforce assignment scope for tasks and schedules
               if (assignScope === 'self' && (toolKey === 'manage_tasks' || toolKey === 'manage_schedules')) {
                 if (parsed.agentId && parsed.agentId !== ctx?.agentId) {
@@ -468,9 +536,10 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if (toolKey === 'manage_tasks' && all[id].status === 'completed') {
                 const { formatValidationFailure, validateTaskCompletion } = await import('../task-validation')
                 const { ensureTaskCompletionReport } = await import('../task-reports')
+                const settings = loadSettings()
                 const report = ensureTaskCompletionReport(all[id] as any)
                 if (report?.relativePath) (all[id] as any).completionReportPath = report.relativePath
-                const validation = validateTaskCompletion(all[id] as any, { report })
+                const validation = validateTaskCompletion(all[id] as any, { report, settings })
                 ;(all[id] as any).validation = validation
                 if (!validation.ok) {
                   all[id].status = 'failed'
@@ -532,7 +601,15 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
   if (hasTool('manage_documents')) {
     tools.push(
       tool(
-        async ({ action, id, filePath, query, limit, metadata, title }) => {
+        async (rawArgs) => {
+          const normalized = normalizeToolInputArgs((rawArgs ?? {}) as Record<string, unknown>)
+          const action = normalized.action as string | undefined
+          const id = normalized.id as string | undefined
+          const filePath = (normalized.filePath ?? normalized.path) as string | undefined
+          const query = normalized.query as string | undefined
+          const limit = normalized.limit as number | undefined
+          const metadata = normalized.metadata as string | undefined
+          const title = normalized.title as string | undefined
           try {
             const documents = loadDocuments()