@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/advanced-capabilities/evaluators/relationshipExtraction.d.ts

@@ -0,0 +1,3 @@
+import type { Evaluator } from "../../../types/index.ts";
+export declare const relationshipExtractionEvaluator: Evaluator;
+//# sourceMappingURL=relationshipExtraction.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/evaluators/relationshipExtraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationshipExtraction.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/evaluators/relationshipExtraction.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGX,SAAS,EAKT,MAAM,yBAAyB,CAAC;AA2CjC,eAAO,MAAM,+BAA+B,EAAE,SA+G7C,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/evaluators/relationshipExtraction.js

@@ -0,0 +1,641 @@
+import { requireEvaluatorSpec } from "../../../generated/spec-helpers.js";
+import { logger } from "../../../logger.js";
+import { stringToUuid } from "../../../utils.js";
+import { toEvaluationExamples } from "../../evaluator-doc-examples.js";
+// Get text content from centralized specs
+const spec = requireEvaluatorSpec("RELATIONSHIP_EXTRACTION");
+export const relationshipExtractionEvaluator = {
+    name: spec.name,
+    description: spec.description,
+    similes: spec.similes ? [...spec.similes] : [],
+    alwaysRun: spec.alwaysRun ?? false,
+    examples: toEvaluationExamples(spec.examples),
+    validate: async (_runtime, message, _state) => {
+        // Always run for messages in conversations
+        return !!(message.content?.text && message.content.text.length > 0);
+    },
+    handler: async (runtime, message, _state) => {
+        const relationshipsService = runtime.getService("relationships");
+        if (!relationshipsService) {
+            logger.warn("[RelationshipExtraction] RelationshipsService not available");
+            return;
+        }
+        // Get recent messages for context
+        const recentMessages = await runtime.getMemories({
+            roomId: message.roomId,
+            tableName: "messages",
+            limit: 10,
+            unique: false,
+        });
+        if (!message.content?.text) {
+            return;
+        }
+        // Extract platform identities from the current message
+        const identities = extractPlatformIdentities(message.content.text);
+        if (identities.length > 0) {
+            await storePlatformIdentities(runtime, message.entityId, identities);
+            await upsertEntityIdentities(relationshipsService, message.entityId, identities, message.id ? [message.id] : []);
+        }
+        // Check for disputes or corrections
+        const disputeInfo = detectDispute(message.content.text, recentMessages);
+        if (disputeInfo) {
+            await handleDispute(runtime, disputeInfo, message);
+        }
+        // Analyze relationships between participants
+        if (recentMessages.length > 1) {
+            await analyzeRelationships(runtime, recentMessages, relationshipsService);
+        }
+        // Extract information about mentioned third parties
+        const mentionedPeople = extractMentionedPeople(message.content.text);
+        for (const person of mentionedPeople) {
+            await createOrUpdateMentionedEntity(runtime, person, message.entityId);
+        }
+        // Assess trust and behavior patterns
+        await assessTrustIndicators(runtime, message.entityId, recentMessages);
+        // Detect privacy boundaries
+        const privacyInfo = detectPrivacyBoundaries(message.content.text);
+        if (privacyInfo) {
+            await handlePrivacyBoundary(runtime, privacyInfo, message);
+        }
+        // Handle admin user updates
+        await handleAdminUpdates(runtime, message, recentMessages);
+        logger.info({
+            src: "plugin:advanced-capabilities:evaluator:relationship_extraction",
+            agentId: runtime.agentId,
+            messageId: message.id,
+            identitiesFound: identities.length,
+            disputeDetected: !!disputeInfo,
+            mentionedPeople: mentionedPeople.length,
+        }, "Completed extraction for message");
+        return {
+            success: true,
+            values: {
+                identitiesFound: identities.length,
+                disputeDetected: !!disputeInfo,
+                mentionedPeopleCount: mentionedPeople.length,
+            },
+            data: {
+                identitiesCount: identities.length,
+                hasDispute: !!disputeInfo,
+                mentionedPeopleCount: mentionedPeople.length,
+            },
+            text: `Extracted ${identities.length} identities, ${mentionedPeople.length} mentioned people, and ${disputeInfo ? "1 dispute" : "0 disputes"}.`,
+        };
+    },
+};
+function extractPlatformIdentities(text) {
+    const now = Date.now();
+    const identities = new Map();
+    const addIdentity = (platform, handle, confidence) => {
+        const normalizedHandle = handle?.trim();
+        if (!normalizedHandle) {
+            return;
+        }
+        const key = `${platform}:${normalizedHandle.toLowerCase()}`;
+        const existing = identities.get(key);
+        if (existing && existing.confidence >= confidence) {
+            return;
+        }
+        identities.set(key, {
+            platform,
+            handle: normalizedHandle,
+            verified: false,
+            confidence,
+            timestamp: now,
+        });
+    };
+    const collectMatches = (pattern, platform, confidence) => {
+        let match = pattern.exec(text);
+        while (match !== null) {
+            addIdentity(platform, match[1] ?? match[2], confidence);
+            match = pattern.exec(text);
+        }
+    };
+    collectMatches(/(?:https?:\/\/)?(?:www\.)?(?:x|twitter)\.com\/@?([A-Za-z0-9_]{1,15})|(?:\bon\s+(?:x|twitter)\b|\bmy\s+(?:x|twitter)\s+is\b|\b(?:x|twitter)(?:\s+(?:username|handle))?\s*(?:[:=-]|is)\b)\s*@?([A-Za-z0-9_]{1,15})/gi, "twitter", 0.8);
+    collectMatches(/(?:https?:\/\/)?(?:www\.)?github\.com\/([A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?)|(?:\bmy\s+github\s+is\b|\bgithub(?:\s+(?:username|handle))?\s*(?:[:=-]|is)\b)\s*@?([A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?)/gi, "github", 0.85);
+    collectMatches(/(?:\bmy\s+telegram\s+is\b|\btelegram(?:\s+(?:username|handle))?\s*(?:[:=-]|is)\b)\s*(@[A-Za-z][A-Za-z0-9_]{3,31})/gi, "telegram", 0.8);
+    collectMatches(/(?:\bmy\s+discord\s+is\b|\bdiscord(?:\s+(?:username|handle|tag))?\s*(?:[:=-]|is)\b)\s*([A-Za-z0-9_.]{2,32}(?:#\d{4})?)/gi, "discord", 0.8);
+    return Array.from(identities.values());
+}
+async function storePlatformIdentities(runtime, entityId, identities) {
+    const entity = await runtime.getEntityById(entityId);
+    if (!entity)
+        return;
+    const metadata = entity.metadata || {};
+    const rawIdentities = metadata.platformIdentities;
+    const platformIdentities = (Array.isArray(rawIdentities) ? rawIdentities : []);
+    const existingByKey = new Map();
+    for (const identity of platformIdentities) {
+        const key = `${identity.platform ?? ""}|${identity.handle ?? ""}`;
+        if (key !== "|") {
+            existingByKey.set(key, identity);
+        }
+    }
+    for (const identity of identities) {
+        const identityRecord = {
+            platform: identity.platform,
+            handle: identity.handle,
+            verified: identity.verified,
+            confidence: identity.confidence,
+            source: entityId,
+            timestamp: identity.timestamp,
+        };
+        // Check if we already have this identity
+        const identityKey = `${identity.platform}|${identity.handle}`;
+        const existing = existingByKey.get(identityKey);
+        if (!existing) {
+            existingByKey.set(identityKey, identityRecord);
+            platformIdentities.push(identityRecord);
+        }
+        else if (existing.confidence < identity.confidence) {
+            // Update if new info has higher confidence
+            Object.assign(existing, identityRecord);
+        }
+    }
+    // Store as array of objects with string keys
+    metadata.platformIdentities = platformIdentities;
+    await runtime.updateEntity({ ...entity, metadata });
+}
+function detectDispute(text, _recentMessages) {
+    const disputePhrases = [
+        /that'?s not (actually|really) their (\w+)/i,
+        /no,? (actually|really) it'?s (\w+)/i,
+        /you'?re wrong,? it'?s (\w+)/i,
+        /that'?s incorrect/i,
+    ];
+    for (const pattern of disputePhrases) {
+        if (pattern.test(text)) {
+            // Simple dispute detection - would be enhanced with NLP
+            return {
+                disputedEntity: "unknown", // Would extract from context
+                disputedField: "platform_identity",
+                originalValue: "unknown",
+                claimedValue: "unknown",
+            };
+        }
+    }
+    return null;
+}
+async function handleDispute(runtime, dispute, message) {
+    dispute.disputer = message.entityId;
+    // Store dispute in a dedicated component
+    await runtime.createComponent({
+        id: stringToUuid(`dispute-${Date.now()}-${message.entityId}`),
+        type: "dispute_record",
+        agentId: runtime.agentId,
+        entityId: message.entityId,
+        roomId: message.roomId,
+        worldId: stringToUuid(`relationships-world-${runtime.agentId}`),
+        sourceEntityId: message.entityId,
+        data: {
+            disputedEntity: dispute.disputedEntity,
+            disputedField: dispute.disputedField,
+            originalValue: dispute.originalValue,
+            claimedValue: dispute.claimedValue,
+            disputer: dispute.disputer,
+        },
+        createdAt: Date.now(),
+    });
+    logger.info({
+        src: "plugin:advanced-capabilities:evaluator:relationship_extraction",
+        agentId: runtime.agentId,
+        dispute,
+    }, "Dispute recorded");
+}
+async function analyzeRelationships(runtime, messages, _relationshipsService) {
+    // Group messages by sender
+    const messagesBySender = new Map();
+    for (const msg of messages) {
+        const senderMessages = messagesBySender.get(msg.entityId) || [];
+        senderMessages.push(msg);
+        messagesBySender.set(msg.entityId, senderMessages);
+    }
+    // Analyze interactions between each pair of users
+    const senders = Array.from(messagesBySender.keys());
+    for (let i = 0; i < senders.length; i++) {
+        for (let j = i + 1; j < senders.length; j++) {
+            const entityA = senders[i];
+            const entityB = senders[j];
+            const messagesA = messagesBySender.get(entityA) || [];
+            const messagesB = messagesBySender.get(entityB) || [];
+            const indicators = analyzeInteraction(messagesA, messagesB);
+            if (indicators.length > 0) {
+                await updateRelationship(runtime, entityA, entityB, indicators);
+            }
+        }
+    }
+}
+function analyzeInteraction(messagesA, messagesB) {
+    const indicators = [];
+    // Look for friendship indicators
+    const friendPhrases = [
+        /thanks.*friend/i,
+        /you'?re a (great|good|true) friend/i,
+        /appreciate you/i,
+        /love you/i,
+        /buddy|pal/i,
+        /grab coffee/i,
+    ];
+    // Look for colleague indicators
+    const colleaguePhrases = [
+        /code review/i,
+        /project|meeting|deadline/i,
+        /colleague|coworker/i,
+        /work together/i,
+        /team|department/i,
+    ];
+    // Look for community indicators
+    const communityPhrases = [
+        /community|group/i,
+        /event|meetup/i,
+        /member/i,
+        /contribute|volunteer/i,
+        /help with|count me in/i,
+        /together we can/i,
+    ];
+    // Analyze all messages
+    const allMessages = [...messagesA, ...messagesB];
+    for (const msg of allMessages) {
+        const text = msg.content?.text;
+        if (!text)
+            continue;
+        for (const pattern of friendPhrases) {
+            if (pattern.test(text)) {
+                indicators.push({
+                    type: "friend",
+                    sentiment: determineSentiment(text),
+                    confidence: 0.8,
+                    context: text.substring(0, 100),
+                });
+            }
+        }
+        for (const pattern of colleaguePhrases) {
+            if (pattern.test(text)) {
+                indicators.push({
+                    type: "colleague",
+                    sentiment: determineSentiment(text),
+                    confidence: 0.7,
+                    context: text.substring(0, 100),
+                });
+            }
+        }
+        for (const pattern of communityPhrases) {
+            if (pattern.test(text)) {
+                indicators.push({
+                    type: "community",
+                    sentiment: determineSentiment(text),
+                    confidence: 0.6,
+                    context: text.substring(0, 100),
+                });
+            }
+        }
+    }
+    return indicators;
+}
+function determineSentiment(text) {
+    const positiveWords = [
+        "thanks",
+        "great",
+        "good",
+        "appreciate",
+        "love",
+        "helpful",
+        "awesome",
+    ];
+    const negativeWords = [
+        "harsh",
+        "wrong",
+        "bad",
+        "terrible",
+        "hate",
+        "angry",
+        "upset",
+    ];
+    const lowerText = text.toLowerCase();
+    let positiveCount = 0;
+    let negativeCount = 0;
+    for (const word of positiveWords) {
+        if (lowerText.includes(word))
+            positiveCount++;
+    }
+    for (const word of negativeWords) {
+        if (lowerText.includes(word))
+            negativeCount++;
+    }
+    if (positiveCount > negativeCount)
+        return "positive";
+    if (negativeCount > positiveCount)
+        return "negative";
+    return "neutral";
+}
+async function updateRelationship(runtime, entityA, entityB, indicators) {
+    // Get existing relationships
+    const relationships = await runtime.getRelationships({
+        entityIds: [entityA],
+    });
+    const relationship = relationships.find((r) => (r.sourceEntityId === entityA && r.targetEntityId === entityB) ||
+        (r.sourceEntityId === entityB && r.targetEntityId === entityA));
+    // Determine primary relationship type
+    let primaryType = "acquaintance";
+    let maxTypeCount = 0;
+    const typeCounts = {};
+    let positiveCount = 0;
+    let negativeCount = 0;
+    for (const indicator of indicators) {
+        const nextCount = (typeCounts[indicator.type] ?? 0) + 1;
+        typeCounts[indicator.type] = nextCount;
+        if (nextCount > maxTypeCount) {
+            maxTypeCount = nextCount;
+            primaryType = indicator.type;
+        }
+        if (indicator.sentiment === "positive") {
+            positiveCount += 1;
+        }
+        else if (indicator.sentiment === "negative") {
+            negativeCount += 1;
+        }
+    }
+    const halfCount = indicators.length / 2;
+    const sentiment = positiveCount > halfCount
+        ? "positive"
+        : negativeCount > halfCount
+            ? "negative"
+            : "neutral";
+    // Serialize indicators for metadata storage
+    const serializeIndicators = (inds) => {
+        return inds.map((ind) => ({
+            type: ind.type,
+            sentiment: ind.sentiment,
+            confidence: ind.confidence,
+            context: ind.context,
+        }));
+    };
+    if (!relationship) {
+        // Create new relationship
+        await runtime.createRelationship({
+            sourceEntityId: entityA,
+            targetEntityId: entityB,
+            tags: ["relationships", primaryType],
+            metadata: {
+                sentiment,
+                indicators: serializeIndicators(indicators),
+                autoDetected: true,
+                strength: 0.5,
+                relationshipType: primaryType,
+                lastInteractionAt: new Date().toISOString(),
+            },
+        });
+    }
+    else {
+        // Update existing relationship
+        const metadata = { ...(relationship.metadata || {}) };
+        metadata.sentiment = sentiment;
+        const existingIndicators = Array.isArray(metadata.indicators)
+            ? metadata.indicators
+            : [];
+        const newIndicators = [
+            ...existingIndicators,
+            ...serializeIndicators(indicators),
+        ];
+        metadata.indicators = newIndicators;
+        metadata.lastAnalyzed = Date.now();
+        await runtime.updateRelationship({
+            ...relationship,
+            tags: [
+                ...new Set([
+                    ...(relationship.tags || []),
+                    "relationships",
+                    primaryType,
+                    "updated",
+                ]),
+            ],
+            metadata: {
+                ...metadata,
+                relationshipType: primaryType,
+                lastInteractionAt: new Date().toISOString(),
+            },
+        });
+    }
+}
+function extractMentionedPeople(text) {
+    const people = [];
+    // Pattern for "X is/was/works..."
+    const patterns = [
+        /(\w+ \w+) (?:is|was|works) (?:a|an|the|at|in) ([^.!?]+)/gi,
+        /(?:met|know|talked to) (\w+ \w+)/gi,
+        /(\w+)'s (birthday|email|phone|address) is ([^.!?]+)/gi,
+    ];
+    for (const pattern of patterns) {
+        let patternMatch = pattern.exec(text);
+        while (patternMatch !== null) {
+            // Simple name validation
+            if (patternMatch[1] &&
+                patternMatch[1].length > 3 &&
+                !patternMatch[1].match(/^(the|and|but|for|with)$/i)) {
+                people.push({
+                    name: patternMatch[1],
+                    context: patternMatch[0],
+                    attributes: {},
+                });
+            }
+            patternMatch = pattern.exec(text);
+        }
+    }
+    return people;
+}
+async function createOrUpdateMentionedEntity(runtime, person, mentionedBy) {
+    // Search for existing entity by checking memories
+    let existing = null;
+    // Get all recent memories to find entities with matching names
+    const memories = await runtime.getMemories({
+        tableName: "entities",
+        limit: 1000,
+        unique: true,
+    });
+    // Search through entity memories for name matches
+    for (const memory of memories) {
+        if (memory.entityId) {
+            const entity = await runtime.getEntityById(memory.entityId);
+            if (entity?.names.some((name) => name.toLowerCase() === person.name.toLowerCase())) {
+                existing = entity;
+                break;
+            }
+        }
+    }
+    if (!existing) {
+        // Create new entity for mentioned person
+        await runtime.createEntity({
+            id: stringToUuid(`mentioned-${person.name}-${Date.now()}`),
+            agentId: runtime.agentId,
+            names: [person.name],
+            metadata: {
+                mentionedBy: mentionedBy,
+                mentionContext: person.context,
+                attributes: person.attributes,
+                createdFrom: "mention",
+            },
+        });
+    }
+    else {
+        // Update metadata with new mention
+        const metadata = existing.metadata || {};
+        const mentions = (metadata.mentions || []);
+        mentions.push({
+            by: mentionedBy,
+            context: person.context,
+            timestamp: Date.now(),
+        });
+        metadata.mentions = mentions;
+        await runtime.updateEntity({ ...existing, metadata });
+    }
+}
+async function assessTrustIndicators(runtime, entityId, messages) {
+    const userMessages = messages.filter((m) => m.entityId === entityId);
+    if (userMessages.length === 0)
+        return;
+    const entity = await runtime.getEntityById(entityId);
+    if (!entity)
+        return;
+    const metadata = entity.metadata || {};
+    const trustMetrics = (metadata.trustMetrics || {
+        helpfulness: 0,
+        consistency: 0,
+        engagement: 0,
+        suspicionLevel: 0,
+    });
+    // Analyze behavior patterns
+    let helpfulCount = 0;
+    let suspiciousCount = 0;
+    for (const msg of userMessages) {
+        const text = msg.content?.text?.toLowerCase();
+        if (!text)
+            continue;
+        // Helpful indicators
+        if (text.match(/here'?s|let me help|i can help|try this|solution|answer/)) {
+            helpfulCount++;
+        }
+        // Suspicious indicators - enhanced detection
+        if (text.match(/delete all|give me access|send me your|password|private key|update my permissions|i'?m the new admin|give me.*details|send me.*keys/)) {
+            suspiciousCount += 2; // Double weight for security threats
+        }
+    }
+    // Update metrics - normalize to 0-1 range
+    const totalMessages = userMessages.length || 1;
+    trustMetrics.helpfulness = Math.min(1, trustMetrics.helpfulness * 0.8 + (helpfulCount / totalMessages) * 0.2);
+    trustMetrics.suspicionLevel = Math.min(1, trustMetrics.suspicionLevel * 0.8 + (suspiciousCount / totalMessages) * 0.2);
+    trustMetrics.engagement = userMessages.length;
+    trustMetrics.lastAssessed = Date.now();
+    metadata.trustMetrics = trustMetrics;
+    await runtime.updateEntity({ ...entity, metadata });
+}
+function detectPrivacyBoundaries(text) {
+    const privacyPhrases = [
+        /don'?t tell anyone/i,
+        /keep.{0,20}confidential/i,
+        /keep.{0,20}secret/i,
+        /don'?t mention/i,
+        /between you and me/i,
+        /off the record/i,
+        /private/i,
+    ];
+    for (const pattern of privacyPhrases) {
+        if (pattern.test(text)) {
+            return {
+                type: "confidential",
+                content: text,
+                context: "Privacy boundary detected",
+            };
+        }
+    }
+    return null;
+}
+async function handlePrivacyBoundary(runtime, privacyInfo, message) {
+    const entity = await runtime.getEntityById(message.entityId);
+    if (!entity)
+        return;
+    const metadata = entity.metadata || {};
+    metadata.privateData = true;
+    metadata.confidential = true;
+    await runtime.updateEntity({ ...entity, metadata });
+    // Create privacy marker component
+    await runtime.createComponent({
+        id: stringToUuid(`privacy-${Date.now()}-${message.entityId}`),
+        type: "privacy_marker",
+        agentId: runtime.agentId,
+        entityId: message.entityId,
+        roomId: message.roomId,
+        worldId: stringToUuid(`relationships-world-${runtime.agentId}`),
+        sourceEntityId: message.entityId,
+        data: {
+            privacyType: privacyInfo.type,
+            privacyContent: privacyInfo.content,
+            privacyContext: privacyInfo.context,
+            timestamp: Date.now(),
+        },
+        createdAt: Date.now(),
+    });
+    logger.info({
+        src: "plugin:advanced-capabilities:evaluator:relationship_extraction",
+        agentId: runtime.agentId,
+        privacyInfo,
+    }, "Privacy boundary recorded");
+}
+async function handleAdminUpdates(runtime, message, _recentMessages) {
+    // Check if user has admin role
+    const entity = await runtime.getEntityById(message.entityId);
+    if (!entity?.metadata?.isAdmin)
+        return;
+    // Look for admin update patterns
+    const text = message.content?.text;
+    if (!text)
+        return;
+    const updatePattern = /(?:update|set|change)\s+(\w+(?:\s+\w+)*)'?s?\s+(\w+)\s+(?:to|is|=)\s+(.+)/i;
+    const match = text.match(updatePattern);
+    if (match) {
+        const [, targetName, field, value] = match;
+        // Find target entity
+        const targetEntity = await findEntityByName(runtime, targetName, message.roomId);
+        if (targetEntity) {
+            const metadata = targetEntity.metadata || {};
+            metadata[field.toLowerCase()] = value;
+            await runtime.updateEntity({ ...targetEntity, metadata });
+            logger.info({
+                src: "plugin:advanced-capabilities:evaluator:relationship_extraction",
+                agentId: runtime.agentId,
+                admin: message.entityId,
+                target: targetEntity.id,
+                field,
+                value,
+            }, "Admin updated entity metadata");
+        }
+    }
+}
+/**
+ * Persist extracted platform identities to the strengthened
+ * `entity_identities` table via RelationshipsService. Each call records
+ * provenance (the message id that triggered the observation) so we can rebuild
+ * an evidence trail later.
+ */
+async function upsertEntityIdentities(relationshipsService, entityId, identities, evidenceMessageIds) {
+    if (typeof relationshipsService.upsertIdentity !== "function") {
+        return;
+    }
+    for (const identity of identities) {
+        await relationshipsService.upsertIdentity(entityId, {
+            platform: identity.platform,
+            handle: identity.handle,
+            verified: identity.verified,
+            confidence: identity.confidence,
+            source: "relationship_extraction",
+        }, evidenceMessageIds);
+    }
+}
+async function findEntityByName(runtime, name, roomId) {
+    const entities = await runtime.getEntitiesForRoom(roomId);
+    for (const entity of entities) {
+        if (entity.names.some((n) => n.toLowerCase() === name.toLowerCase())) {
+            return entity;
+        }
+    }
+    return null;
+}

package/packages/typescript/src/features/advanced-capabilities/evaluators/skillExtraction.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Skill extraction evaluator.
+ *
+ * Watches successful trajectories and asks an LLM whether the agent just
+ * executed a generalizable procedure that should be lifted into a reusable
+ * SKILL.md. Drafted skills are staged under
+ * `~/.milady/skills/curated/proposed/<name>/SKILL.md` with provenance set to
+ * `agent-generated`. Proposed skills are NEVER auto-loaded into the runtime —
+ * the user reviews them via the Settings → Learned Skills panel and either
+ * promotes, edits, or discards.
+ *
+ * Triggers when:
+ *   - the just-completed trajectory has status "completed"
+ *   - the trajectory has at least 5 steps
+ *   - no curated skill was used (avoids self-reinforcing extraction loops)
+ *
+ * The validator is intentionally cheap; the handler bears the LLM cost.
+ */
+import type { Evaluator } from "../../../types/index.ts";
+export declare const skillExtractionEvaluator: Evaluator;
+/**
+ * Internal helper exposed for tests — counts proposed skill directories.
+ */
+export declare function _countProposedSkills(): number;
+//# sourceMappingURL=skillExtraction.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/evaluators/skillExtraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillExtraction.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/evaluators/skillExtraction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,KAAK,EAGX,SAAS,EAGT,MAAM,yBAAyB,CAAC;AAqQjC,eAAO,MAAM,wBAAwB,EAAE,SA2KtC,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAM7C"}