@troykelly/openclaw-projects 0.0.11 → 0.0.13

package/dist/register-openclaw.js

@@ -8,15 +8,20 @@
  * - CLI registered via `api.registerCli()`
  */
 import { ZodError } from 'zod';
-import { validateRawConfig, resolveConfigSecretsSync, redactConfig } from './config.js';
-import { createLogger } from './logger.js';
 import { createApiClient } from './api-client.js';
+import { redactConfig, resolveConfigSecretsSync, validateRawConfig } from './config.js';
 import { extractContext, getUserScopeKey } from './context.js';
-import { createSkillStorePutTool, createSkillStoreGetTool, createSkillStoreListTool, createSkillStoreDeleteTool, createSkillStoreSearchTool, createSkillStoreCollectionsTool, createSkillStoreAggregateTool, } from './tools/index.js';
-import { createGatewayMethods, registerGatewayRpcMethods } from './gateway/rpc-methods.js';
 import { createOAuthGatewayMethods, registerOAuthGatewayRpcMethods } from './gateway/oauth-rpc-methods.js';
-import { createNotificationService } from './services/notification-service.js';
+import { createGatewayMethods, registerGatewayRpcMethods } from './gateway/rpc-methods.js';
 import { createAutoCaptureHook, createGraphAwareRecallHook } from './hooks.js';
+import { createLogger } from './logger.js';
+import { createNotificationService } from './services/notification-service.js';
+import { createContextSearchTool, createLinksQueryTool, createLinksRemoveTool, createLinksSetTool, createProjectSearchTool, createSkillStoreAggregateTool, createSkillStoreCollectionsTool, createSkillStoreDeleteTool, createSkillStoreGetTool, createSkillStoreListTool, createSkillStorePutTool, createSkillStoreSearchTool, } from './tools/index.js';
+import { autoLinkInboundMessage } from './utils/auto-linker.js';
+import { blendScores, computeGeoScore, haversineDistanceKm } from './utils/geo.js';
+import { createBoundaryMarkers, detectInjectionPatternsAsync, sanitizeMessageForContext, sanitizeMetadataField, wrapExternalMessage, } from './utils/injection-protection.js';
+import { injectionLogLimiter } from './utils/injection-log-rate-limiter.js';
+import { reverseGeocode } from './utils/nominatim.js';
 /**
  * Convert internal ToolResult format to AgentToolResult format expected by OpenClaw Gateway.
  *
@@ -73,6 +78,28 @@ const memoryRecallSchema = {
             description: 'Scope search to a specific relationship between contacts',
             format: 'uuid',
         },
+        location: {
+            type: 'object',
+            description: 'Current location for geo-aware recall ranking',
+            properties: {
+                lat: { type: 'number', minimum: -90, maximum: 90 },
+                lng: { type: 'number', minimum: -180, maximum: 180 },
+            },
+            required: ['lat', 'lng'],
+        },
+        location_radius_km: {
+            type: 'number',
+            description: 'Filter memories within this radius (km) of the given location',
+            minimum: 0.1,
+            maximum: 100,
+        },
+        location_weight: {
+            type: 'number',
+            description: 'Weight for geo scoring (0 = content only, 1 = geo only)',
+            minimum: 0,
+            maximum: 1,
+            default: 0.3,
+        },
     },
     required: ['query'],
 };
@@ -121,6 +148,35 @@ const memoryStoreSchema = {
             description: 'Scope memory to a specific relationship between contacts',
             format: 'uuid',
         },
+        location: {
+            type: 'object',
+            description: 'Geographic location to associate with this memory',
+            properties: {
+                lat: {
+                    type: 'number',
+                    description: 'Latitude (-90 to 90)',
+                    minimum: -90,
+                    maximum: 90,
+                },
+                lng: {
+                    type: 'number',
+                    description: 'Longitude (-180 to 180)',
+                    minimum: -180,
+                    maximum: 180,
+                },
+                address: {
+                    type: 'string',
+                    description: 'Street address (max 500 chars)',
+                    maxLength: 500,
+                },
+                place_label: {
+                    type: 'string',
+                    description: 'Short place name (max 200 chars)',
+                    maxLength: 200,
+                },
+            },
+            required: ['lat', 'lng'],
+        },
     },
     required: ['text'],
 };
@@ -213,18 +269,22 @@ const todoListSchema = {
             description: 'Filter by project ID',
             format: 'uuid',
         },
-        status: {
-            type: 'string',
-            description: 'Filter by todo status',
-            enum: ['pending', 'in_progress', 'completed', 'all'],
-            default: 'pending',
+        completed: {
+            type: 'boolean',
+            description: 'Filter by completion status. true = completed only, false = active only, omit = all.',
         },
         limit: {
             type: 'integer',
             description: 'Maximum number of todos to return',
             minimum: 1,
-            maximum: 100,
-            default: 20,
+            maximum: 200,
+            default: 50,
+        },
+        offset: {
+            type: 'integer',
+            description: 'Offset for pagination',
+            minimum: 0,
+            default: 0,
         },
     },
 };
@@ -278,6 +338,95 @@ const todoCompleteSchema = {
     },
     required: ['todoId'],
 };
+/**
+ * Todo search tool JSON Schema (Issue #1216)
+ */
+const todoSearchSchema = {
+    type: 'object',
+    properties: {
+        query: {
+            type: 'string',
+            description: 'Natural language search query for finding work items',
+            minLength: 1,
+            maxLength: 1000,
+        },
+        limit: {
+            type: 'integer',
+            description: 'Maximum number of results to return',
+            minimum: 1,
+            maximum: 50,
+            default: 10,
+        },
+        kind: {
+            type: 'string',
+            description: 'Filter by work item kind',
+            enum: ['task', 'project', 'initiative', 'epic', 'issue'],
+        },
+        status: {
+            type: 'string',
+            description: 'Filter by status (e.g., open, completed, in_progress)',
+            maxLength: 50,
+        },
+    },
+    required: ['query'],
+};
+/**
+ * Project search tool JSON Schema (Issue #1217)
+ */
+const projectSearchSchema = {
+    type: 'object',
+    properties: {
+        query: {
+            type: 'string',
+            description: 'Natural language search query for finding projects',
+            minLength: 1,
+            maxLength: 1000,
+        },
+        limit: {
+            type: 'integer',
+            description: 'Maximum number of results to return',
+            minimum: 1,
+            maximum: 50,
+            default: 10,
+        },
+        status: {
+            type: 'string',
+            description: 'Filter by project status',
+            enum: ['active', 'completed', 'archived'],
+        },
+    },
+    required: ['query'],
+};
+/**
+ * Context search tool JSON Schema (Issue #1219)
+ */
+const contextSearchSchema = {
+    type: 'object',
+    properties: {
+        query: {
+            type: 'string',
+            description: 'Natural language search query across memories, todos, projects, and messages',
+            minLength: 1,
+            maxLength: 1000,
+        },
+        entity_types: {
+            type: 'array',
+            description: 'Filter to specific entity types. Defaults to all (memory, todo, project, message).',
+            items: {
+                type: 'string',
+                enum: ['memory', 'todo', 'project', 'message'],
+            },
+        },
+        limit: {
+            type: 'integer',
+            description: 'Maximum number of results to return',
+            minimum: 1,
+            maximum: 50,
+            default: 10,
+        },
+    },
+    required: ['query'],
+};
 /**
  * Contact search tool JSON Schema
  */
@@ -877,6 +1026,90 @@ const skillStoreAggregateSchema = {
     },
     required: ['skill_id', 'operation'],
 };
+/**
+ * Entity linking tool JSON Schemas (Issue #1220)
+ */
+const linksSetSchema = {
+    type: 'object',
+    properties: {
+        source_type: {
+            type: 'string',
+            description: 'Type of the source entity',
+            enum: ['memory', 'todo', 'project', 'contact'],
+        },
+        source_id: {
+            type: 'string',
+            description: 'UUID of the source entity',
+            format: 'uuid',
+        },
+        target_type: {
+            type: 'string',
+            description: 'Type of the target entity or external reference',
+            enum: ['memory', 'todo', 'project', 'contact', 'github_issue', 'url'],
+        },
+        target_ref: {
+            type: 'string',
+            description: 'Reference to the target: UUID for internal entities, "owner/repo#N" for GitHub issues, URL for urls',
+            minLength: 1,
+        },
+        label: {
+            type: 'string',
+            description: 'Optional label describing the link (e.g., "spawned from", "tracks", "related to")',
+            maxLength: 100,
+        },
+    },
+    required: ['source_type', 'source_id', 'target_type', 'target_ref'],
+};
+const linksQuerySchema = {
+    type: 'object',
+    properties: {
+        entity_type: {
+            type: 'string',
+            description: 'Type of the entity to query links for',
+            enum: ['memory', 'todo', 'project', 'contact'],
+        },
+        entity_id: {
+            type: 'string',
+            description: 'UUID of the entity to query links for',
+            format: 'uuid',
+        },
+        link_types: {
+            type: 'array',
+            description: 'Optional filter to only return links to specific entity types',
+            items: {
+                type: 'string',
+                enum: ['memory', 'todo', 'project', 'contact', 'github_issue', 'url'],
+            },
+        },
+    },
+    required: ['entity_type', 'entity_id'],
+};
+const linksRemoveSchema = {
+    type: 'object',
+    properties: {
+        source_type: {
+            type: 'string',
+            description: 'Type of the source entity',
+            enum: ['memory', 'todo', 'project', 'contact'],
+        },
+        source_id: {
+            type: 'string',
+            description: 'UUID of the source entity',
+            format: 'uuid',
+        },
+        target_type: {
+            type: 'string',
+            description: 'Type of the target entity or external reference',
+            enum: ['memory', 'todo', 'project', 'contact', 'github_issue', 'url'],
+        },
+        target_ref: {
+            type: 'string',
+            description: 'Reference to the target',
+            minLength: 1,
+        },
+    },
+    required: ['source_type', 'source_id', 'target_type', 'target_ref'],
+};
 /**
  * Create tool execution handlers
  */
@@ -884,9 +1117,11 @@ function createToolHandlers(state) {
     const { config, logger, apiClient, userId } = state;
     return {
         async memory_recall(params) {
-            const { query, limit = config.maxRecallMemories, category, tags, relationship_id, } = params;
+            const { query, limit = config.maxRecallMemories, category, tags, relationship_id, location, location_radius_km, location_weight, } = params;
             try {
-                const queryParams = new URLSearchParams({ q: query, limit: String(limit) });
+                // Over-fetch when location is provided to allow geo re-ranking
+                const apiLimit = location ? Math.min(limit * 3, 60) : limit;
+                const queryParams = new URLSearchParams({ q: query, limit: String(apiLimit) });
                 if (category)
                     queryParams.set('memory_type', category);
                 if (tags && tags.length > 0)
@@ -897,7 +1132,36 @@ function createToolHandlers(state) {
                 if (!response.success) {
                     return { success: false, error: response.error.message };
                 }
-                const memories = response.data.results ?? [];
+                let memories = (response.data.results ?? []).map((m) => ({
+                    ...m,
+                    category: m.type === 'note' ? 'other' : m.type,
+                    score: m.similarity,
+                }));
+                // Apply geo re-ranking if location is provided
+                if (location) {
+                    const { lat: qLat, lng: qLng } = location;
+                    const weight = location_weight ?? 0.3;
+                    // Filter by radius if specified
+                    if (location_radius_km !== undefined) {
+                        memories = memories.filter((m) => {
+                            if (m.lat == null || m.lng == null)
+                                return false;
+                            return haversineDistanceKm(qLat, qLng, m.lat, m.lng) <= location_radius_km;
+                        });
+                    }
+                    // Compute blended scores and re-sort
+                    memories = memories
+                        .map((m) => {
+                        const contentScore = m.score ?? 0;
+                        let geoScore = 0.5;
+                        if (m.lat != null && m.lng != null) {
+                            geoScore = computeGeoScore(haversineDistanceKm(qLat, qLng, m.lat, m.lng));
+                        }
+                        return { ...m, score: blendScores(contentScore, geoScore, weight) };
+                    })
+                        .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
+                        .slice(0, limit);
+                }
                 const content = memories.length > 0 ? memories.map((m) => `- [${m.type}] ${m.content}`).join('\n') : 'No relevant memories found.';
                 return {
                     success: true,
@@ -914,7 +1178,7 @@ function createToolHandlers(state) {
         },
         async memory_store(params) {
             // Accept 'text' (OpenClaw native) or 'content' (backwards compat)
-            const { text, content: contentAlias, category = 'other', importance = 0.7, tags, relationship_id, } = params;
+            const { text, content: contentAlias, category = 'other', importance = 0.7, tags, relationship_id, location, } = params;
             const memoryText = text || contentAlias;
             if (!memoryText) {
                 return { success: false, error: 'text is required' };
@@ -931,6 +1195,24 @@ function createToolHandlers(state) {
                     payload.tags = tags;
                 if (relationship_id)
                     payload.relationship_id = relationship_id;
+                if (location) {
+                    payload.lat = location.lat;
+                    payload.lng = location.lng;
+                    // Reverse geocode if address is missing and Nominatim is configured
+                    if (!location.address && config.nominatimUrl) {
+                        const geocoded = await reverseGeocode(location.lat, location.lng, config.nominatimUrl);
+                        if (geocoded) {
+                            payload.address = geocoded.address;
+                            if (!location.place_label && geocoded.placeLabel) {
+                                payload.place_label = geocoded.placeLabel;
+                            }
+                        }
+                    }
+                    if (location.address)
+                        payload.address = location.address;
+                    if (location.place_label)
+                        payload.place_label = location.place_label;
+                }
                 const response = await apiClient.post('/api/memories/unified', payload, { userId });
                 if (!response.success) {
                     return { success: false, error: response.error.message };
@@ -1012,6 +1294,7 @@ function createToolHandlers(state) {
                 const queryParams = new URLSearchParams({ item_type: 'project', limit: String(limit) });
                 if (status !== 'all')
                     queryParams.set('status', status);
+                queryParams.set('user_email', userId); // Issue #1172: scope by user
                 const response = await apiClient.get(`/api/work-items?${queryParams}`, { userId });
                 if (!response.success) {
                     return { success: false, error: response.error.message };
@@ -1031,7 +1314,7 @@ function createToolHandlers(state) {
         async project_get(params) {
             const { projectId } = params;
             try {
-                const response = await apiClient.get(`/api/work-items/${projectId}`, { userId });
+                const response = await apiClient.get(`/api/work-items/${projectId}?user_email=${encodeURIComponent(userId)}`, { userId });
                 if (!response.success) {
                     return { success: false, error: response.error.message };
                 }
@@ -1052,7 +1335,7 @@ function createToolHandlers(state) {
         async project_create(params) {
             const { name, description, status = 'active', } = params;
             try {
-                const response = await apiClient.post('/api/work-items', { title: name, description, item_type: 'project', status }, { userId });
+                const response = await apiClient.post('/api/work-items', { title: name, description, item_type: 'project', status, user_email: userId }, { userId });
                 if (!response.success) {
                     return { success: false, error: response.error.message };
                 }
@@ -1070,22 +1353,41 @@ function createToolHandlers(state) {
             }
         },
         async todo_list(params) {
-            const { projectId, status = 'pending', limit = 20, } = params;
+            const { projectId, completed, limit = 50, offset = 0, } = params;
             try {
-                const queryParams = new URLSearchParams({ item_type: 'task', limit: String(limit) });
-                if (status !== 'all')
-                    queryParams.set('status', status);
+                const queryParams = new URLSearchParams({
+                    item_type: 'task',
+                    limit: String(limit),
+                    offset: String(offset),
+                    user_email: userId, // Issue #1172: scope by user
+                });
                 if (projectId)
                     queryParams.set('parent_work_item_id', projectId);
+                if (completed !== undefined) {
+                    queryParams.set('status', completed ? 'completed' : 'active');
+                }
                 const response = await apiClient.get(`/api/work-items?${queryParams}`, { userId });
                 if (!response.success) {
                     return { success: false, error: response.error.message };
                 }
                 const todos = response.data.items ?? [];
-                const content = todos.length > 0 ? todos.map((t) => `- [${t.status}] ${t.title}`).join('\n') : 'No todos found.';
+                const total = response.data.total ?? todos.length;
+                if (todos.length === 0) {
+                    return {
+                        success: true,
+                        data: { content: 'No todos found.', details: { count: 0, total: 0, todos: [] } },
+                    };
+                }
+                const content = todos
+                    .map((t) => {
+                    const checkbox = t.completed ? '[x]' : '[ ]';
+                    const dueStr = t.dueDate ? ` (due: ${t.dueDate})` : '';
+                    return `- ${checkbox} ${t.title}${dueStr}`;
+                })
+                    .join('\n');
                 return {
                     success: true,
-                    data: { content, details: { count: todos.length, todos } },
+                    data: { content, details: { count: todos.length, total, todos } },
                 };
             }
             catch (error) {
@@ -1096,7 +1398,7 @@ function createToolHandlers(state) {
         async todo_create(params) {
             const { title, description, projectId, priority = 'medium', dueDate, } = params;
             try {
-                const body = { title, description, item_type: 'task', priority };
+                const body = { title, description, item_type: 'task', priority, user_email: userId };
                 if (projectId)
                     body.parent_work_item_id = projectId;
                 if (dueDate)
@@ -1121,7 +1423,7 @@ function createToolHandlers(state) {
         async todo_complete(params) {
             const { todoId } = params;
             try {
-                const response = await apiClient.patch(`/api/work-items/${todoId}/status`, { status: 'completed' }, { userId });
+                const response = await apiClient.patch(`/api/work-items/${todoId}/status?user_email=${encodeURIComponent(userId)}`, { status: 'completed' }, { userId });
                 if (!response.success) {
                     return { success: false, error: response.error.message };
                 }
@@ -1135,10 +1437,87 @@ function createToolHandlers(state) {
                 return { success: false, error: 'Failed to complete todo' };
             }
         },
+        async todo_search(params) {
+            const { query, limit = 10, kind, status, } = params;
+            if (!query || query.trim().length === 0) {
+                return { success: false, error: 'query is required' };
+            }
+            try {
+                // Over-fetch by 3x to compensate for client-side kind/status filtering (Issue #1216 review fix)
+                const fetchLimit = kind || status ? Math.min(limit * 3, 50) : limit;
+                const queryParams = new URLSearchParams({
+                    q: query.trim(),
+                    types: 'work_item',
+                    limit: String(fetchLimit),
+                    semantic: 'true',
+                    user_email: userId, // Issue #1216: scope results to current user
+                });
+                const response = await apiClient.get(`/api/search?${queryParams}`, { userId });
+                if (!response.success) {
+                    return { success: false, error: response.error.message };
+                }
+                let results = response.data.results ?? [];
+                // Client-side filtering by kind and status, then truncate to requested limit
+                if (kind) {
+                    results = results.filter((r) => r.metadata?.kind === kind);
+                }
+                if (status) {
+                    results = results.filter((r) => r.metadata?.status === status);
+                }
+                results = results.slice(0, limit);
+                if (results.length === 0) {
+                    return {
+                        success: true,
+                        data: {
+                            content: 'No matching work items found.',
+                            details: { count: 0, results: [], searchType: response.data.search_type },
+                        },
+                    };
+                }
+                const content = results
+                    .map((r) => {
+                    const kindStr = r.metadata?.kind ? `[${r.metadata.kind}]` : '';
+                    const statusStr = r.metadata?.status ? ` (${r.metadata.status})` : '';
+                    const snippetStr = r.snippet ? ` - ${r.snippet}` : '';
+                    return `- ${kindStr} **${r.title}**${statusStr}${snippetStr}`;
+                })
+                    .join('\n');
+                return {
+                    success: true,
+                    data: {
+                        content,
+                        details: {
+                            count: results.length,
+                            results: results.map((r) => ({
+                                id: r.id,
+                                title: r.title,
+                                snippet: r.snippet,
+                                score: r.score,
+                                kind: r.metadata?.kind,
+                                status: r.metadata?.status,
+                            })),
+                            searchType: response.data.search_type,
+                        },
+                    },
+                };
+            }
+            catch (error) {
+                logger.error('todo_search failed', { error });
+                return { success: false, error: 'Failed to search work items' };
+            }
+        },
+        async project_search(params) {
+            const tool = createProjectSearchTool({ client: apiClient, logger, config, userId });
+            return tool.execute(params);
+        },
+        async context_search(params) {
+            const tool = createContextSearchTool({ client: apiClient, logger, config, userId });
+            return tool.execute(params);
+        },
         async contact_search(params) {
             const { query, limit = 10 } = params;
             try {
-                const queryParams = new URLSearchParams({ search: query, limit: String(limit) });
+                const queryParams = new URLSearchParams({ search: query, limit: String(limit), user_email: userId });
                 const response = await apiClient.get(`/api/contacts?${queryParams}`, {
                     userId,
                 });
@@ -1160,9 +1539,7 @@ function createToolHandlers(state) {
         async contact_get(params) {
             const { contactId } = params;
             try {
-                const response = await apiClient.get(`/api/contacts/${contactId}`, {
-                    userId,
-                });
+                const response = await apiClient.get(`/api/contacts/${contactId}?user_email=${encodeURIComponent(userId)}`, { userId });
                 if (!response.success) {
                     return { success: false, error: response.error.message };
                 }
@@ -1188,7 +1565,7 @@ function createToolHandlers(state) {
             const { name, notes } = params;
             try {
                 // API requires displayName, not name. Email/phone are stored as separate contact_endpoint records.
-                const response = await apiClient.post('/api/contacts', { displayName: name, notes }, { userId });
+                const response = await apiClient.post('/api/contacts', { displayName: name, notes, user_email: userId }, { userId });
                 if (!response.success) {
                     return { success: false, error: response.error.message };
                 }
@@ -1285,13 +1662,6 @@ function createToolHandlers(state) {
         },
         async email_send(params) {
             const { to, subject, body, htmlBody, threadId, idempotencyKey } = params;
-            // Check Postmark configuration
-            if (!config.postmarkToken || !config.postmarkFromEmail) {
-                return {
-                    success: false,
-                    error: 'Postmark is not configured. Please configure Postmark credentials.',
-                };
-            }
             // Validate email format
             const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
             if (!emailRegex.test(to)) {
@@ -1329,7 +1699,7 @@ function createToolHandlers(state) {
                 hasIdempotencyKey: !!idempotencyKey,
             });
             try {
-                const response = await apiClient.post('/api/email/messages/send', { to, subject, body, htmlBody, threadId, idempotencyKey }, { userId });
+                const response = await apiClient.post('/api/postmark/email/send', { to, subject, body, htmlBody, threadId, idempotencyKey }, { userId });
                 if (!response.success) {
                     logger.error('email_send API error', {
                         userId,
@@ -1432,15 +1802,50 @@ function createToolHandlers(state) {
                     resultCount: messages.length,
                     total,
                 });
-                // Format content for display
+                // SECURITY: Run injection detection on the FULL message body BEFORE any
+                // truncation. Bodies are later truncated to 100 chars for display, but
+                // detection must see the complete content to catch payloads that an
+                // attacker could hide beyond the truncation boundary. (Issue #1258)
+                // Rate-limited to prevent log flooding from volume attacks. (#1257)
+                for (const m of messages) {
+                    if (m.direction === 'inbound' && m.body) {
+                        const detection = await detectInjectionPatternsAsync(m.body, {
+                            promptGuardUrl: config.promptGuardUrl,
+                        });
+                        if (detection.detected) {
+                            const logDecision = injectionLogLimiter.shouldLog(userId);
+                            if (logDecision.log) {
+                                logger.warn(logDecision.summary ? 'injection detection log summary for previous window' : 'potential prompt injection detected in message_search result', {
+                                    userId,
+                                    messageId: m.id,
+                                    patterns: detection.patterns,
+                                    source: detection.source,
+                                    ...(logDecision.suppressed > 0 && { suppressedCount: logDecision.suppressed }),
+                                });
+                            }
+                        }
+                    }
+                }
+                // Format content for display with injection protection.
+                // NOTE: Truncation happens here AFTER detection above — do not reorder.
+                // Generate a per-invocation nonce for boundary markers (#1255)
+                const { nonce } = createBoundaryMarkers();
                 const content = messages.length > 0
                     ? messages
                         .map((m) => {
                         const prefix = m.direction === 'inbound' ? '←' : '→';
-                        const contact = m.contactName || 'Unknown';
+                        const contact = sanitizeMetadataField(m.contactName || 'Unknown', nonce);
+                        const safeChannel = sanitizeMetadataField(m.channel, nonce);
                         const similarity = `(${Math.round(m.similarity * 100)}%)`;
-                        const bodyText = m.body || '';
-                        return `${prefix} [${m.channel}] ${contact} ${similarity}: ${bodyText.substring(0, 100)}${bodyText.length > 100 ? '...' : ''}`;
+                        const rawBody = m.body || '';
+                        const truncatedBody = rawBody.substring(0, 100) + (rawBody.length > 100 ? '...' : '');
+                        const bodyText = sanitizeMessageForContext(truncatedBody, {
+                            direction: m.direction,
+                            channel: m.channel,
+                            sender: m.contactName || 'Unknown',
+                            nonce,
+                        });
+                        return `${prefix} [${safeChannel}] ${contact} ${similarity}: ${bodyText}`;
                     })
                         .join('\n')
                     : 'No messages found matching your query.';
@@ -1502,17 +1907,24 @@ function createToolHandlers(state) {
                     threadCount: results.length,
                     total,
                 });
+                // Format content with injection protection.
+                // Sanitize all fields that may contain external message content.
+                // Generate a per-invocation nonce for boundary markers (#1255)
+                const { nonce: threadListNonce } = createBoundaryMarkers();
                 const content = results.length > 0
                     ? results
                         .map((r) => {
                         // Handle both thread and search result formats
                         if ('channel' in r) {
                             const t = r;
-                            const contact = t.contactName || t.endpointValue || 'Unknown';
+                            const safeContact = sanitizeMetadataField(t.contactName || t.endpointValue || 'Unknown', threadListNonce);
+                            const safeChannel = sanitizeMetadataField(t.channel, threadListNonce);
                             const msgCount = t.messageCount ? `${t.messageCount} message${t.messageCount !== 1 ? 's' : ''}` : '';
-                            return `[${t.channel}] ${contact}${msgCount ? ` - ${msgCount}` : ''}`;
+                            return `[${safeChannel}] ${safeContact}${msgCount ? ` - ${msgCount}` : ''}`;
                         }
-                        return `- ${r.title || r.snippet || r.id}`;
+                        const safeTitle = r.title ? sanitizeMetadataField(r.title, threadListNonce) : '';
+                        const wrappedSnippet = r.snippet ? wrapExternalMessage(r.snippet, { nonce: threadListNonce }) : '';
+                        return `- ${safeTitle || wrappedSnippet || r.id}`;
                     })
                         .join('\n')
                     : 'No threads found.';
@@ -1571,14 +1983,45 @@ function createToolHandlers(state) {
                     threadId,
                     messageCount: messages.length,
                 });
-                const contact = thread.contactName || thread.endpointValue || 'Unknown';
-                const header = `Thread with ${contact} [${thread.channel}]`;
+                // Generate a per-invocation nonce for boundary markers (#1255)
+                const { nonce: threadGetNonce } = createBoundaryMarkers();
+                const contact = sanitizeMetadataField(thread.contactName || thread.endpointValue || 'Unknown', threadGetNonce);
+                const safeChannel = sanitizeMetadataField(thread.channel, threadGetNonce);
+                const header = `Thread with ${contact} [${safeChannel}]`;
+                // Detect and log potential injection patterns in inbound messages
+                // Rate-limited to prevent log flooding from volume attacks. (#1257)
+                for (const m of messages) {
+                    if (m.direction === 'inbound' && m.body) {
+                        const detection = await detectInjectionPatternsAsync(m.body, {
+                            promptGuardUrl: config.promptGuardUrl,
+                        });
+                        if (detection.detected) {
+                            const logDecision = injectionLogLimiter.shouldLog(userId);
+                            if (logDecision.log) {
+                                logger.warn(logDecision.summary ? 'injection detection log summary for previous window' : 'potential prompt injection detected in thread_get result', {
+                                    userId,
+                                    threadId,
+                                    messageId: m.id,
+                                    patterns: detection.patterns,
+                                    source: detection.source,
+                                    ...(logDecision.suppressed > 0 && { suppressedCount: logDecision.suppressed }),
+                                });
+                            }
+                        }
+                    }
+                }
                 const messageContent = messages.length > 0
                     ? messages
                         .map((m) => {
                         const prefix = m.direction === 'inbound' ? '←' : '→';
                         const timestamp = new Date(m.createdAt).toLocaleString();
-                        return `${prefix} [${timestamp}] ${m.body}`;
+                        const body = sanitizeMessageForContext(m.body || '', {
+                            direction: m.direction,
+                            channel: thread.channel,
+                            sender: contact,
+                            nonce: threadGetNonce,
+                        });
+                        return `${prefix} [${timestamp}] ${body}`;
                     })
                         .join('\n')
                     : 'No messages in this thread.';
@@ -1623,6 +2066,7 @@ function createToolHandlers(state) {
                     contact_a,
                     contact_b,
                     relationship_type: relationship,
+                    user_email: userId, // Issue #1172: scope by user
                 };
                 if (notes) {
                     body.notes = notes;
@@ -1669,15 +2113,40 @@ function createToolHandlers(state) {
                 hasTypeFilter: !!type_filter,
             });
             try {
-                const queryParams = new URLSearchParams({ contact_id: contact });
-                if (type_filter) {
-                    queryParams.set('relationship_type_id', type_filter);
+                // Resolve contact to a UUID — accept UUID directly or search by name
+                const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+                let contactId;
+                if (uuidRegex.test(contact)) {
+                    contactId = contact;
                 }
-                const response = await apiClient.get(`/api/relationships?${queryParams}`, { userId });
+                else {
+                    // Search for contact by name (Issue #1172: scope by user_email)
+                    const searchParams = new URLSearchParams({ search: contact, limit: '1', user_email: userId });
+                    const searchResponse = await apiClient.get(`/api/contacts?${searchParams}`, { userId });
+                    if (!searchResponse.success) {
+                        return { success: false, error: searchResponse.error.message };
+                    }
+                    const contacts = searchResponse.data.contacts ?? [];
+                    if (contacts.length === 0) {
+                        return { success: false, error: 'Contact not found.' };
+                    }
+                    contactId = contacts[0].id;
+                }
+                // Use graph traversal endpoint which returns relatedContacts
+                const response = await apiClient.get(`/api/contacts/${contactId}/relationships?user_email=${encodeURIComponent(userId)}`, { userId });
                 if (!response.success) {
+                    if (response.error.code === 'NOT_FOUND') {
+                        return { success: false, error: 'Contact not found.' };
+                    }
                     return { success: false, error: response.error.message };
                 }
-                const { contactId, contactName, relatedContacts } = response.data;
+                let { relatedContacts } = response.data;
+                const { contactName } = response.data;
+                // Apply type_filter client-side if provided
+                if (type_filter && relatedContacts.length > 0) {
+                    const filterLower = type_filter.toLowerCase();
+                    relatedContacts = relatedContacts.filter((rel) => rel.relationshipTypeName.toLowerCase().includes(filterLower) || rel.relationshipTypeLabel.toLowerCase().includes(filterLower));
+                }
                 if (relatedContacts.length === 0) {
                     return {
                         success: true,
@@ -1825,6 +2294,18 @@ function createToolHandlers(state) {
                 skill_store_aggregate: (params) => aggregateTool.execute(params),
             };
         })(),
+        // Entity link tools: delegate to tool modules (Issue #1220)
+        ...(() => {
+            const toolOptions = { client: apiClient, logger, config, userId };
+            const setTool = createLinksSetTool(toolOptions);
+            const queryTool = createLinksQueryTool(toolOptions);
+            const removeTool = createLinksRemoveTool(toolOptions);
+            return {
+                links_set: (params) => setTool.execute(params),
+                links_query: (params) => queryTool.execute(params),
+                links_remove: (params) => removeTool.execute(params),
+            };
+        })(),
     };
 }
 /**
@@ -1876,7 +2357,7 @@ export const registerOpenClaw = (api) => {
     const state = { config, logger, apiClient, userId };
     // Create tool handlers
     const handlers = createToolHandlers(state);
-    // Register all 27 tools with correct OpenClaw Gateway execute signature
+    // Register all 30 tools with correct OpenClaw Gateway execute signature
     // Signature: (toolCallId: string, params: T, signal?: AbortSignal, onUpdate?: (partial: any) => void) => AgentToolResult
     const tools = [
         {
@@ -1960,6 +2441,33 @@ export const registerOpenClaw = (api) => {
                 return toAgentToolResult(result);
             },
         },
+        {
+            name: 'todo_search',
+            description: 'Search todos and work items by natural language query. Uses semantic and text search to find relevant items. Optionally filter by kind or status.',
+            parameters: todoSearchSchema,
+            execute: async (_toolCallId, params, _signal, _onUpdate) => {
+                const result = await handlers.todo_search(params);
+                return toAgentToolResult(result);
+            },
+        },
+        {
+            name: 'project_search',
+            description: 'Search projects by natural language query. Uses semantic and text search to find relevant projects. Optionally filter by status (active, completed, archived).',
+            parameters: projectSearchSchema,
+            execute: async (_toolCallId, params, _signal, _onUpdate) => {
+                const result = await handlers.project_search(params);
+                return toAgentToolResult(result);
+            },
+        },
+        {
+            name: 'context_search',
+            description: 'Search across memories, todos, projects, and messages simultaneously. Use when you need broad context about a topic, person, or project. Returns a blended ranked list from all entity types. Optionally filter by entity_types to narrow the search.',
+            parameters: contextSearchSchema,
+            execute: async (_toolCallId, params, _signal, _onUpdate) => {
+                const result = await handlers.context_search(params);
+                return toAgentToolResult(result);
+            },
+        },
         {
             name: 'contact_search',
             description: 'Search contacts by name, email, or other fields. Use to find people.',
@@ -2122,6 +2630,33 @@ export const registerOpenClaw = (api) => {
                 return toAgentToolResult(result);
             },
         },
+        {
+            name: 'links_set',
+            description: 'Create a link between two entities (memory, todo, project, contact, GitHub issue, or URL). Links are bidirectional and can be traversed from either end. Use to connect related items for cross-reference and context discovery.',
+            parameters: linksSetSchema,
+            execute: async (_toolCallId, params, _signal, _onUpdate) => {
+                const result = await handlers.links_set(params);
+                return toAgentToolResult(result);
+            },
+        },
+        {
+            name: 'links_query',
+            description: 'Query all links for an entity (memory, todo, project, or contact). Returns connected entities including other items, GitHub issues, and URLs. Optionally filter by link target types.',
+            parameters: linksQuerySchema,
+            execute: async (_toolCallId, params, _signal, _onUpdate) => {
+                const result = await handlers.links_query(params);
+                return toAgentToolResult(result);
+            },
+        },
+        {
+            name: 'links_remove',
+            description: 'Remove a link between two entities. Deletes both directions of the link. Use when a connection is no longer relevant or was created in error.',
+            parameters: linksRemoveSchema,
+            execute: async (_toolCallId, params, _signal, _onUpdate) => {
+                const result = await handlers.links_remove(params);
+                return toAgentToolResult(result);
+            },
+        },
     ];
     for (const tool of tools) {
         api.registerTool(tool);
@@ -2228,6 +2763,54 @@ export const registerOpenClaw = (api) => {
             api.registerHook('agentEnd', agentEndHandler);
         }
     }
+    // Register auto-linking hook for inbound messages (Issue #1223)
+    // When an inbound SMS/email arrives, automatically link the thread to
+    // matching contacts (by sender email/phone) and related projects/todos
+    // (by semantic content matching).
+    {
+        /**
+         * message_received handler: Extracts sender and content info from the
+         * inbound message event and runs auto-linking in the background.
+         * Failures are logged but never crash message processing.
+         */
+        const messageReceivedHandler = async (event, _ctx) => {
+            // Skip if no thread ID (nothing to link to)
+            if (!event.threadId) {
+                logger.debug('Auto-link skipped: no threadId in message_received event');
+                return;
+            }
+            // Skip if no content and no sender info (nothing to match on)
+            if (!event.content && !event.senderEmail && !event.senderPhone && !event.sender) {
+                logger.debug('Auto-link skipped: no content or sender info in event');
+                return;
+            }
+            try {
+                await autoLinkInboundMessage({
+                    client: apiClient,
+                    logger,
+                    userId,
+                    message: {
+                        threadId: event.threadId,
+                        senderEmail: event.senderEmail ?? (event.sender?.includes('@') ? event.sender : undefined),
+                        senderPhone: event.senderPhone ?? (event.sender && !event.sender.includes('@') ? event.sender : undefined),
+                        content: event.content ?? '',
+                    },
+                });
+            }
+            catch (error) {
+                // Hook errors should never crash inbound message processing
+                logger.error('Auto-link hook failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        };
+        if (typeof api.on === 'function') {
+            api.on('message_received', messageReceivedHandler);
+        }
+        else {
+            api.registerHook('messageReceived', messageReceivedHandler);
+        }
+    }
     // Register Gateway RPC methods (Issue #324)
     const gatewayMethods = createGatewayMethods({
         logger,
@@ -2327,6 +2910,8 @@ export const schemas = {
     todoList: todoListSchema,
     todoCreate: todoCreateSchema,
     todoComplete: todoCompleteSchema,
+    todoSearch: todoSearchSchema,
+    projectSearch: projectSearchSchema,
     contactSearch: contactSearchSchema,
     contactGet: contactGetSchema,
     contactCreate: contactCreateSchema,