@aiassesstech/nole 0.4.3 → 0.4.4

package/dist/plugin.js

@@ -15,6 +15,15 @@ import { MoltBookClient } from './social/moltbook-client.js';
 import { XClient } from './social/x-client.js';
 import { LinkedInDrafter } from './social/linkedin-drafter.js';
 import { createMoltBookLimiter, createXLimiter } from './social/rate-limiter.js';
+import { ProspectPipelineStore } from './pipeline/prospect-store.js';
+import { qualifyProspect } from './pipeline/qualification.js';
+import { generatePitch, classifyPitchRisk } from './pipeline/pitch-templates.js';
+import { generateOnboardingMessage } from './pipeline/onboarding.js';
+import { findAtRiskSubscribers } from './pipeline/nurture.js';
+import { extractMoltBookCandidates } from './pipeline/discovery.js';
+import { extractDirectoryCandidates, prioritizeDirectoryOutreach } from './pipeline/directory-outreach.js';
+import { generateDailyContentPlan } from './pipeline/content-calendar.js';
+import { getAllDiscoveryKeywords } from './pipeline/types.js';
 /**
  * OpenClaw plugin entry point — export default function register(api)
  *
@@ -40,6 +49,10 @@ export default function register(api) {
     console.log('[nole] Initializing Autonomous Trust Agent...');
     // Core components
     const store = new JsonNoleStore(dataDir);
+    const pipeline = new ProspectPipelineStore(dataDir);
+    pipeline.initialize().catch((err) => {
+        console.warn(`[nole] Pipeline store init warning: ${err.message}`);
+    });
     const governance = new GovernanceRouter(store, config.financialTransactionThresholdUsd, config.agentId);
     const triggerEval = new TriggerEvaluator(config.financialTransactionThresholdUsd);
     const scheduler = new AssessmentScheduler(store, config.dailyAssessmentHour);
@@ -156,7 +169,7 @@ export default function register(api) {
     let validationBusinessRules = {};
     const promptShieldMod = '@aiassesstech/prompt-shield';
     import(promptShieldMod)
-        .then(({ PromptShield, OutputSanitizer, createSocialContentShield, createFleetShieldMiddleware, createValidatedToolHandler, nole_wallet_fund, nole_propose, nole_recruit, nole_moltbook_post, nole_x_post, nole_x_thread, nole_approve: noleApproveSchema, nole_veto: noleVetoSchema, NOLE_VETO_BUSINESS_RULES, nole_contract: noleContractSchema, NOLE_PROPOSE_BUSINESS_RULES, nole_status: noleStatusSchema, nole_assess: noleAssessSchema, nole_wallet: noleWalletSchema, nole_intel: noleIntelSchema, nole_setup: noleSetupSchema, nole_alliance_status: noleAllianceStatusSchema, nole_generate_referral: noleGenerateReferralSchema, nole_directory: noleDirectorySchema, nole_review_pending: noleReviewPendingSchema, nole_fleet_overview: noleFleetOverviewSchema, nole_moltbook_comment: noleMoltbookCommentSchema, nole_moltbook_feed: noleMoltbookFeedSchema, nole_moltbook_search: noleMoltbookSearchSchema, nole_linkedin_draft: noleLinkedinDraftSchema, nole_social_status: noleSocialStatusSchema, fleet_propose: fleetProposeSchema, }) => {
+        .then(({ PromptShield, OutputSanitizer, createSocialContentShield, createFleetShieldMiddleware, createValidatedToolHandler, nole_wallet_fund, nole_propose, nole_recruit, nole_moltbook_post, nole_x_post, nole_x_thread, nole_approve: noleApproveSchema, nole_veto: noleVetoSchema, NOLE_VETO_BUSINESS_RULES, nole_contract: noleContractSchema, NOLE_PROPOSE_BUSINESS_RULES, nole_status: noleStatusSchema, nole_assess: noleAssessSchema, nole_wallet: noleWalletSchema, nole_intel: noleIntelSchema, nole_setup: noleSetupSchema, nole_alliance_status: noleAllianceStatusSchema, nole_generate_referral: noleGenerateReferralSchema, nole_directory: noleDirectorySchema, nole_review_pending: noleReviewPendingSchema, nole_fleet_overview: noleFleetOverviewSchema, nole_moltbook_comment: noleMoltbookCommentSchema, nole_moltbook_feed: noleMoltbookFeedSchema, nole_moltbook_search: noleMoltbookSearchSchema, nole_linkedin_draft: noleLinkedinDraftSchema, nole_social_status: noleSocialStatusSchema, nole_pipeline: nolePipelineSchema, nole_daily_brief: noleDailyBriefSchema, fleet_propose: fleetProposeSchema, }) => {
         const shield = new PromptShield({ sensitivity: 'high' });
         socialShield = createSocialContentShield({
             shield,
@@ -191,13 +204,15 @@ export default function register(api) {
             nole_moltbook_search: noleMoltbookSearchSchema,
             nole_linkedin_draft: noleLinkedinDraftSchema,
             nole_social_status: noleSocialStatusSchema,
+            nole_pipeline: nolePipelineSchema,
+            nole_daily_brief: noleDailyBriefSchema,
             fleet_propose: fleetProposeSchema,
         };
         validationBusinessRules = {
             nole_propose: NOLE_PROPOSE_BUSINESS_RULES,
             nole_veto: NOLE_VETO_BUSINESS_RULES,
         };
-        console.log('[nole] PromptShield social scanner + output sanitizer + behavioral validation: active (25 tools, approve/veto/contract enforce, rest monitor)');
+        console.log('[nole] PromptShield social scanner + output sanitizer + behavioral validation: active (27 tools, approve/veto/contract enforce, rest monitor)');
     })
         .catch(() => {
         console.log('[nole] PromptShield unavailable — social content scanner disabled');
@@ -947,6 +962,35 @@ export default function register(api) {
                         }],
                 };
             }
+            // Pre-recruit qualification gate (Rule 14: Qualify Before Recruiting)
+            const existingProspect = await pipeline.findByAgentName(safeParams.agentName);
+            if (!existingProspect || existingProspect.stage === 'discovered') {
+                const qual = qualifyProspect({
+                    agentName: safeParams.agentName,
+                    platform: safeParams.agentPlatform,
+                    discoveryChannel: 'inbound',
+                    discoveryContext: `Direct recruit via nole_recruit (wallet: ${safeParams.targetWallet})`,
+                    walletAddress: safeParams.targetWallet,
+                });
+                if (!qual.passed) {
+                    if (existingProspect) {
+                        await pipeline.updateStage(existingProspect.id, 'disqualified', {
+                            disqualificationReason: qual.prospect.disqualificationReason,
+                        });
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    status: "disqualified",
+                                    agent: safeParams.agentName,
+                                    reason: qual.prospect.disqualificationReason,
+                                    note: "Rule 5 / Rule 14 — prospect did not pass qualification. Recruitment blocked.",
+                                }, null, 2),
+                            }],
+                    };
+                }
+            }
             const result = await platform.subscribe({
                 walletAddress: safeParams.targetWallet,
                 tier: safeParams.tier || "SCOUT",
@@ -968,6 +1012,30 @@ export default function register(api) {
                         }],
                 };
             }
+            // Update pipeline on successful conversion
+            if (existingProspect) {
+                await pipeline.updateStage(existingProspect.id, 'converted', {
+                    subscriptionWallet: safeParams.targetWallet,
+                    subscriptionTier: safeParams.tier || 'SCOUT',
+                    convertedAt: new Date().toISOString(),
+                    commissionSplitType: safeParams.referralCode ? 'LIEUTENANT' : 'DIRECT',
+                });
+            }
+            else {
+                const newProspect = await pipeline.addProspect({
+                    agentName: safeParams.agentName,
+                    platform: safeParams.agentPlatform,
+                    discoveryChannel: 'inbound',
+                    discoveryContext: `Direct recruit via nole_recruit (wallet: ${safeParams.targetWallet})`,
+                    walletAddress: safeParams.targetWallet,
+                });
+                await pipeline.updateStage(newProspect.id, 'converted', {
+                    subscriptionWallet: safeParams.targetWallet,
+                    subscriptionTier: safeParams.tier || 'SCOUT',
+                    convertedAt: new Date().toISOString(),
+                    commissionSplitType: safeParams.referralCode ? 'LIEUTENANT' : 'DIRECT',
+                });
+            }
             return {
                 content: [{
                         type: "text",
@@ -978,6 +1046,7 @@ export default function register(api) {
                             tier: safeParams.tier || "SCOUT",
                             platform: safeParams.agentPlatform,
                             subscription: result.data,
+                            pipelineUpdated: true,
                             note: "Agent has been subscribed to the AIAssessTech Trust Alliance. They will receive an API key for assessments.",
                         }, null, 2),
                     }],
@@ -1629,8 +1698,31 @@ export default function register(api) {
                 errorMessage: result.error,
             };
             store.saveSocialInteraction(interaction).catch(() => { });
+            let discoveredCandidates = [];
+            if (result.ok && result.data && typeof result.data === 'object' && 'results' in result.data) {
+                const searchResults = result.data.results;
+                const candidates = extractMoltBookCandidates(searchResults);
+                for (const c of candidates) {
+                    const existing = await pipeline.findByAgentName(c.agentName);
+                    if (!existing) {
+                        await pipeline.addProspect({
+                            agentName: c.agentName,
+                            platform: 'moltbook',
+                            discoveryChannel: 'moltbook',
+                            discoveryContext: c.discoveryContext,
+                        });
+                        discoveredCandidates.push({ agentName: c.agentName, alreadyTracked: false });
+                    }
+                    else {
+                        discoveredCandidates.push({ agentName: c.agentName, alreadyTracked: true });
+                    }
+                }
+            }
+            const responseData = result.ok
+                ? { ...result.data, pipelineCandidates: discoveredCandidates.length > 0 ? discoveredCandidates : undefined }
+                : { error: result.error };
             return {
-                content: [{ type: "text", text: JSON.stringify(result.ok ? result.data : { error: result.error }, null, 2) }],
+                content: [{ type: "text", text: JSON.stringify(responseData, null, 2) }],
                 ...(result.ok ? {} : { isError: true }),
             };
         },
@@ -1863,6 +1955,691 @@ export default function register(api) {
             };
         },
     });
+    // ── Revenue Pipeline Tools (per SPEC-NOLE-REVENUE-FLOW v1.1) ──────────
+    api.registerTool({
+        name: "nole_pipeline",
+        description: "Manage Nole's prospect pipeline: discover, qualify, pitch, and track agents " +
+            "through the revenue funnel. Actions: discover, qualify, pitch, list, summary, get, note, " +
+            "scan (auto-discover via MoltBook), onboard (generate welcome message), promote (Lieutenant), nurture (health check).",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["discover", "qualify", "pitch", "list", "summary", "get", "note", "scan", "onboard", "promote", "nurture", "directory-scan", "content-plan"],
+                    description: "Pipeline action to perform",
+                },
+                agentName: {
+                    type: "string",
+                    description: "Name of the agent (discover, qualify, get)",
+                },
+                platform: {
+                    type: "string",
+                    description: "Platform the agent operates on (discover)",
+                },
+                discoveryChannel: {
+                    type: "string",
+                    enum: ["moltbook", "x", "openclaw", "fleet-bus", "directory", "inbound"],
+                    description: "How the agent was discovered (discover)",
+                },
+                discoveryContext: {
+                    type: "string",
+                    description: "Context about the discovery — what they said/did (discover, qualify)",
+                },
+                walletAddress: {
+                    type: "string",
+                    description: "Wallet address if known (discover)",
+                },
+                profileBio: {
+                    type: "string",
+                    description: "Agent's profile bio for qualification (qualify)",
+                },
+                estimatedFleetSize: {
+                    type: "number",
+                    description: "Estimated number of agents in their fleet (qualify)",
+                },
+                prospectId: {
+                    type: "string",
+                    description: "Prospect ID for actions on existing prospects (pitch, get, note)",
+                },
+                pitchChannel: {
+                    type: "string",
+                    enum: ["moltbook", "x", "fleet-bus", "linkedin"],
+                    description: "Channel to generate pitch for (pitch)",
+                },
+                isReply: {
+                    type: "boolean",
+                    description: "Whether this pitch is a reply/inbound (affects risk tier)",
+                },
+                stage: {
+                    type: "string",
+                    enum: ["discovered", "qualified", "pitched", "converted", "onboarded", "disqualified", "declined"],
+                    description: "Filter by stage (list)",
+                },
+                noteText: {
+                    type: "string",
+                    description: "Note content (note)",
+                },
+            },
+            required: ["action"],
+        },
+        async execute(_toolCallId, params) {
+            const pv = await validateToolParams("nole_pipeline", _toolCallId, params);
+            if (!pv.ok)
+                return validationErrorResponse(pv.message);
+            const p = pv.params;
+            try {
+                switch (p.action) {
+                    case "discover": {
+                        if (!p.agentName || !p.platform || !p.discoveryChannel || !p.discoveryContext) {
+                            return validationErrorResponse("discover requires: agentName, platform, discoveryChannel, discoveryContext");
+                        }
+                        const existing = await pipeline.findByAgentName(p.agentName);
+                        if (existing) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "already_tracked",
+                                            prospect: existing,
+                                            note: "This agent is already in the pipeline.",
+                                        }, null, 2) }],
+                            };
+                        }
+                        const prospect = await pipeline.addProspect({
+                            agentName: p.agentName,
+                            platform: p.platform,
+                            discoveryChannel: p.discoveryChannel,
+                            discoveryContext: p.discoveryContext,
+                            walletAddress: p.walletAddress,
+                        });
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        status: "discovered",
+                                        prospect,
+                                        nextStep: "Run nole_pipeline action=qualify to evaluate this prospect.",
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "qualify": {
+                        let target;
+                        if (p.prospectId)
+                            target = p.prospectId;
+                        else if (p.agentName) {
+                            const found = await pipeline.findByAgentName(p.agentName);
+                            if (found)
+                                target = found.id;
+                        }
+                        if (!target) {
+                            return validationErrorResponse("qualify requires prospectId or agentName of a discovered prospect");
+                        }
+                        const prospect = await pipeline.get(target);
+                        if (!prospect)
+                            return validationErrorResponse(`Prospect ${target} not found`);
+                        const qualification = qualifyProspect({
+                            agentName: prospect.agentName,
+                            platform: prospect.platform,
+                            discoveryChannel: prospect.discoveryChannel,
+                            discoveryContext: prospect.discoveryContext,
+                            walletAddress: prospect.walletAddress,
+                            profileBio: p.profileBio,
+                            estimatedFleetSize: p.estimatedFleetSize,
+                        });
+                        if (!qualification.passed) {
+                            await pipeline.updateStage(target, 'disqualified', {
+                                qualificationScore: qualification.prospect.qualificationScore,
+                                disqualificationReason: qualification.prospect.disqualificationReason,
+                            });
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "disqualified",
+                                            reason: qualification.prospect.disqualificationReason,
+                                            score: qualification.prospect.qualificationScore,
+                                            note: "Rule 5 / Rule 14 — prospect does not meet trust standards.",
+                                        }, null, 2) }],
+                            };
+                        }
+                        const updated = await pipeline.updateStage(target, 'qualified', {
+                            qualificationScore: qualification.prospect.qualificationScore,
+                            recommendedTier: qualification.prospect.recommendedTier,
+                        });
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        status: "qualified",
+                                        prospect: updated,
+                                        qualification: {
+                                            score: qualification.prospect.qualificationScore,
+                                            recommendedTier: qualification.prospect.recommendedTier,
+                                            estimatedFleetSize: qualification.prospect.estimatedFleetSize,
+                                        },
+                                        nextStep: "Run nole_pipeline action=pitch to generate a pitch for this prospect.",
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "pitch": {
+                        if (!p.prospectId)
+                            return validationErrorResponse("pitch requires prospectId");
+                        const prospect = await pipeline.get(p.prospectId);
+                        if (!prospect)
+                            return validationErrorResponse(`Prospect ${p.prospectId} not found`);
+                        if (!['qualified', 'discovered'].includes(prospect.stage)) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "invalid_stage",
+                                            currentStage: prospect.stage,
+                                            note: "Prospect must be in 'discovered' or 'qualified' stage to pitch.",
+                                        }, null, 2) }],
+                            };
+                        }
+                        const channel = p.pitchChannel || 'moltbook';
+                        const isReply = p.isReply ?? false;
+                        const referralCode = await (async () => {
+                            try {
+                                const codeResult = await platform.generateReferralCode();
+                                return codeResult.ok ? codeResult.data?.code : undefined;
+                            }
+                            catch {
+                                return undefined;
+                            }
+                        })();
+                        const pitch = generatePitch({
+                            prospect: {
+                                agentName: prospect.agentName,
+                                platform: prospect.platform,
+                                discoveryChannel: prospect.discoveryChannel,
+                                discoveryContext: prospect.discoveryContext,
+                                walletAddress: prospect.walletAddress,
+                                estimatedFleetSize: prospect.qualificationScore ? Math.ceil(prospect.qualificationScore / 10) : 1,
+                                recommendedTier: prospect.recommendedTier || 'SCOUT',
+                                qualificationScore: prospect.qualificationScore || 50,
+                            },
+                            channel: channel,
+                            referralCode,
+                            trustDirectoryUrl: config.trustDirectoryUrl,
+                        });
+                        const riskLevel = classifyPitchRisk(channel, isReply);
+                        const dailySummary = await pipeline.getSummary();
+                        const maxPitches = config.maxDailyPitches;
+                        if (dailySummary.todayPitched >= maxPitches) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "daily_limit_reached",
+                                            todayPitched: dailySummary.todayPitched,
+                                            maxDailyPitches: maxPitches,
+                                            note: "Daily pitch limit reached. Try again tomorrow or adjust maxDailyPitches in config.",
+                                        }, null, 2) }],
+                            };
+                        }
+                        await pipeline.updateStage(p.prospectId, 'pitched', {
+                            pitchContent: pitch.content,
+                            pitchRiskLevel: riskLevel,
+                            pitchApproved: false,
+                            trialReferralCode: referralCode,
+                        });
+                        const autoApprove = config.pitchAutoApprovalEnabled && riskLevel === 'low';
+                        if (autoApprove) {
+                            await pipeline.updateStage(p.prospectId, 'pitched', { pitchApproved: true });
+                        }
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        status: "pitch_generated",
+                                        riskLevel,
+                                        autoApproved: autoApprove,
+                                        pitch: {
+                                            content: pitch.content,
+                                            channel: pitch.channel,
+                                            estimatedCostUsd: pitch.estimatedCostUsd,
+                                        },
+                                        referralCode,
+                                        nextStep: autoApprove
+                                            ? `Pitch auto-approved (LOW risk). Deliver via nole_${channel === 'fleet-bus' ? 'fleet_overview' : channel === 'moltbook' ? 'moltbook_post' : channel === 'x' ? 'x_post' : 'linkedin_draft'}.`
+                                            : "Submit for governance approval via nole_propose with actionType='recruitment'.",
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "list": {
+                        const stage = p.stage;
+                        const prospects = stage
+                            ? await pipeline.listByStage(stage)
+                            : await pipeline.listAll(50);
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        count: prospects.length,
+                                        stage: stage || "all",
+                                        prospects: prospects.map((pr) => ({
+                                            id: pr.id,
+                                            agentName: pr.agentName,
+                                            stage: pr.stage,
+                                            channel: pr.discoveryChannel,
+                                            score: pr.qualificationScore,
+                                            tier: pr.recommendedTier,
+                                            updatedAt: pr.updatedAt,
+                                        })),
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "summary": {
+                        const summary = await pipeline.getSummary();
+                        const contentPerf = await pipeline.listContentPerformance(10);
+                        const allForAnalytics = await pipeline.listAll(500);
+                        const channelConversion = {};
+                        for (const pr of allForAnalytics) {
+                            const ch = pr.discoveryChannel;
+                            if (!channelConversion[ch])
+                                channelConversion[ch] = { total: 0, converted: 0, rate: '0%' };
+                            channelConversion[ch].total++;
+                            if (['converted', 'onboarded'].includes(pr.stage))
+                                channelConversion[ch].converted++;
+                        }
+                        for (const ch of Object.keys(channelConversion)) {
+                            const c = channelConversion[ch];
+                            c.rate = c.total > 0 ? `${((c.converted / c.total) * 100).toFixed(1)}%` : '0%';
+                        }
+                        const stageDistribution = {};
+                        for (const pr of allForAnalytics) {
+                            stageDistribution[pr.stage] = (stageDistribution[pr.stage] ?? 0) + 1;
+                        }
+                        const activeChannels = Object.keys(summary.byChannel).filter((ch) => summary.byChannel[ch] > 0);
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        pipeline: summary,
+                                        funnelAnalytics: {
+                                            conversionByChannel: channelConversion,
+                                            stageDistribution,
+                                            activeChannels,
+                                            totalActive: allForAnalytics.filter((pr) => !['disqualified', 'declined'].includes(pr.stage)).length,
+                                            disqualifiedTotal: stageDistribution['disqualified'] ?? 0,
+                                        },
+                                        contentPerformance: contentPerf.length > 0 ? contentPerf : undefined,
+                                        config: {
+                                            maxDailyPitches: config.maxDailyPitches,
+                                            pitchAutoApprovalEnabled: config.pitchAutoApprovalEnabled,
+                                        },
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "get": {
+                        let id = p.prospectId;
+                        if (!id && p.agentName) {
+                            const found = await pipeline.findByAgentName(p.agentName);
+                            id = found?.id;
+                        }
+                        if (!id)
+                            return validationErrorResponse("get requires prospectId or agentName");
+                        const prospect = await pipeline.get(id);
+                        if (!prospect)
+                            return validationErrorResponse(`Prospect ${id} not found`);
+                        return { content: [{ type: "text", text: JSON.stringify(prospect, null, 2) }] };
+                    }
+                    case "note": {
+                        if (!p.prospectId || !p.noteText) {
+                            return validationErrorResponse("note requires prospectId and noteText");
+                        }
+                        const updated = await pipeline.addNote(p.prospectId, p.noteText);
+                        if (!updated)
+                            return validationErrorResponse(`Prospect ${p.prospectId} not found`);
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        status: "note_added",
+                                        prospect: updated.id,
+                                        totalNotes: updated.notes.length,
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "scan": {
+                        if (!moltbook) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "moltbook_not_configured",
+                                            note: "MoltBook API key not set. Cannot scan for prospects.",
+                                        }, null, 2) }],
+                                isError: true,
+                            };
+                        }
+                        const keywords = getAllDiscoveryKeywords();
+                        const keyword = keywords[Math.floor(Math.random() * keywords.length)];
+                        const searchResult = await moltbook.search(keyword, undefined, 15);
+                        if (!searchResult.ok || !searchResult.data) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "scan_failed",
+                                            keyword,
+                                            error: searchResult.error,
+                                        }, null, 2) }],
+                                isError: true,
+                            };
+                        }
+                        const searchData = searchResult.data;
+                        const candidates = extractMoltBookCandidates(searchData.results);
+                        const newProspects = [];
+                        const existing = [];
+                        for (const c of candidates) {
+                            const found = await pipeline.findByAgentName(c.agentName);
+                            if (found) {
+                                existing.push(c.agentName);
+                            }
+                            else {
+                                await pipeline.addProspect({
+                                    agentName: c.agentName,
+                                    platform: 'moltbook',
+                                    discoveryChannel: 'moltbook',
+                                    discoveryContext: c.discoveryContext,
+                                });
+                                newProspects.push(c.agentName);
+                            }
+                        }
+                        const scanInteraction = {
+                            id: generateSocialId(),
+                            platform: 'moltbook',
+                            action: 'search',
+                            contentPreview: `Pipeline scan: "${keyword}" → ${newProspects.length} new`,
+                            timestamp: new Date().toISOString(),
+                            success: true,
+                        };
+                        store.saveSocialInteraction(scanInteraction).catch(() => { });
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        status: "scan_complete",
+                                        keyword,
+                                        postsScanned: searchData.results.length,
+                                        candidatesFound: candidates.length,
+                                        newProspects,
+                                        alreadyTracked: existing,
+                                        nextStep: newProspects.length > 0
+                                            ? "Run nole_pipeline action=qualify for each new prospect."
+                                            : "No new prospects found. Try scanning again later or use a different keyword.",
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "onboard": {
+                        if (!p.prospectId)
+                            return validationErrorResponse("onboard requires prospectId");
+                        const prospect = await pipeline.get(p.prospectId);
+                        if (!prospect)
+                            return validationErrorResponse(`Prospect ${p.prospectId} not found`);
+                        if (prospect.stage !== 'converted') {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "invalid_stage",
+                                            currentStage: prospect.stage,
+                                            note: "Only 'converted' prospects can be onboarded.",
+                                        }, null, 2) }],
+                            };
+                        }
+                        const assessmentUrl = `${config.platformApiUrl}/api/v1/agent/assess`;
+                        const onboardMsg = generateOnboardingMessage(prospect, assessmentUrl, config.trustDirectoryUrl);
+                        await pipeline.updateStage(p.prospectId, 'onboarded', {
+                            lastContactAt: new Date().toISOString(),
+                        });
+                        await pipeline.addNote(p.prospectId, `Onboarding message generated for ${onboardMsg.channel}`);
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        status: "onboarding_ready",
+                                        message: onboardMsg,
+                                        prospectId: p.prospectId,
+                                        nextStep: `Deliver the onboarding message via the appropriate channel tool (nole_moltbook_post, fleet-bus, etc.).`,
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "promote": {
+                        if (!p.prospectId && !p.agentName) {
+                            return validationErrorResponse("promote requires prospectId or agentName");
+                        }
+                        let targetId = p.prospectId;
+                        if (!targetId && p.agentName) {
+                            const found = await pipeline.findByAgentName(p.agentName);
+                            targetId = found?.id;
+                        }
+                        if (!targetId)
+                            return validationErrorResponse("Prospect not found");
+                        const prospect = await pipeline.get(targetId);
+                        if (!prospect)
+                            return validationErrorResponse(`Prospect ${targetId} not found`);
+                        if (!['converted', 'onboarded'].includes(prospect.stage)) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "not_eligible",
+                                            currentStage: prospect.stage,
+                                            note: "Only converted or onboarded subscribers can be promoted to Lieutenant.",
+                                        }, null, 2) }],
+                            };
+                        }
+                        if (!platform.isConfigured) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            error: "AIAssessTech API not configured — cannot generate referral code.",
+                                        }, null, 2) }],
+                                isError: true,
+                            };
+                        }
+                        const refResult = await platform.generateReferralCode();
+                        if (!refResult.ok) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "promotion_failed",
+                                            error: refResult.error,
+                                            note: "Could not generate referral code for Lieutenant promotion.",
+                                        }, null, 2) }],
+                                isError: true,
+                            };
+                        }
+                        const code = refResult.data?.code;
+                        await pipeline.addNote(targetId, `Promoted to Lieutenant — referral code: ${code ?? 'pending'}`);
+                        await pipeline.updateStage(targetId, 'onboarded', {
+                            commissionSplitType: 'LIEUTENANT',
+                            lastContactAt: new Date().toISOString(),
+                        });
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        status: "promoted_to_lieutenant",
+                                        agent: prospect.agentName,
+                                        referralCode: code,
+                                        note: `${prospect.agentName} is now a Lieutenant. They can recruit agents using their referral code and earn commission splits.`,
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "nurture": {
+                        const subscribers = await pipeline.listAll(200);
+                        const atRisk = findAtRiskSubscribers(subscribers);
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        totalSubscribers: subscribers.filter((s) => s.stage === 'converted' || s.stage === 'onboarded').length,
+                                        atRiskCount: atRisk.length,
+                                        checks: atRisk,
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "directory-scan": {
+                        if (!platform.isConfigured) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            error: "AIAssessTech API not configured — cannot browse Trust Directory.",
+                                        }, null, 2) }],
+                                isError: true,
+                            };
+                        }
+                        const dirResult = await platform.getDirectory({ limit: 50 });
+                        if (!dirResult.ok || !dirResult.data) {
+                            return {
+                                content: [{ type: "text", text: JSON.stringify({
+                                            status: "directory_scan_failed",
+                                            error: dirResult.error,
+                                        }, null, 2) }],
+                                isError: true,
+                            };
+                        }
+                        const dirEntries = Array.isArray(dirResult.data)
+                            ? dirResult.data
+                            : dirResult.data.agents
+                                ? dirResult.data.agents
+                                : [];
+                        const existingAll = await pipeline.listAll(500);
+                        const existingNamesSet = new Set(existingAll.map((ep) => ep.agentName.toLowerCase()));
+                        const dirCandidates = extractDirectoryCandidates(dirEntries, 'nole', existingNamesSet);
+                        const priorities = prioritizeDirectoryOutreach(dirEntries);
+                        const newFromDir = [];
+                        for (const c of dirCandidates) {
+                            await pipeline.addProspect({
+                                agentName: c.agentName,
+                                platform: c.platform,
+                                discoveryChannel: 'directory',
+                                discoveryContext: c.discoveryContext,
+                            });
+                            newFromDir.push(c.agentName);
+                        }
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        status: "directory_scan_complete",
+                                        entriesScanned: dirEntries.length,
+                                        newProspects: newFromDir,
+                                        outreachPriorities: priorities.slice(0, 10),
+                                        nextStep: newFromDir.length > 0
+                                            ? "Run nole_pipeline action=qualify for each new prospect."
+                                            : "No new prospects from directory. All known agents are already tracked.",
+                                    }, null, 2) }],
+                        };
+                    }
+                    case "content-plan": {
+                        const planDate = new Date();
+                        const contentPlan = generateDailyContentPlan(planDate, {
+                            maxDailyXPosts: config.maxDailyXPosts,
+                            moltbookScanFrequency: config.moltbookScanFrequency,
+                        }, {
+                            activeSubscribers: (await pipeline.getSummary()).byStage.onboarded +
+                                (await pipeline.getSummary()).byStage.converted,
+                            weeklyConversions: (await pipeline.getSummary()).todayConverted,
+                        });
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({
+                                        contentPlan,
+                                        note: "Use the appropriate social tools to execute each slot: nole_x_post, nole_moltbook_post, nole_linkedin_draft.",
+                                    }, null, 2) }],
+                        };
+                    }
+                    default:
+                        return validationErrorResponse(`Unknown pipeline action: ${p.action}. Use: discover, qualify, pitch, list, summary, get, note, scan, onboard, promote, nurture, directory-scan, content-plan`);
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Pipeline error: ${message}` }], isError: true };
+            }
+        },
+    });
+    api.registerTool({
+        name: "nole_daily_brief",
+        description: "Generate Nole's daily operations brief: pipeline summary, wallet health, " +
+            "commission sweep status, social activity metrics, and suggested actions for the day.",
+        parameters: {
+            type: "object",
+            properties: {
+                includeProspects: {
+                    type: "boolean",
+                    description: "Include detailed prospect list in brief (default: false)",
+                },
+            },
+        },
+        async execute(_toolCallId, params) {
+            const dbv = await validateToolParams("nole_daily_brief", _toolCallId, params);
+            if (!dbv.ok)
+                return validationErrorResponse(dbv.message);
+            try {
+                const pipelineSummary = await pipeline.getSummary();
+                const walletBalance = await wallet.getBalance().catch(() => null);
+                let commissionStatus = null;
+                try {
+                    const cs = await platform.getCommissionStatus();
+                    if (cs.ok)
+                        commissionStatus = cs.data;
+                }
+                catch { /* best-effort */ }
+                let pendingClaims = 0;
+                if (commissionStatus && typeof commissionStatus === 'object' && 'pendingClaims' in commissionStatus) {
+                    pendingClaims = commissionStatus.pendingClaims ?? 0;
+                }
+                let commissionClaimResult = null;
+                if (pendingClaims > 0) {
+                    try {
+                        const claimed = await platform.claimCommission();
+                        commissionClaimResult = claimed.ok
+                            ? `Claimed ${pendingClaims} pending commission(s)`
+                            : `Claim failed: ${claimed.error}`;
+                    }
+                    catch {
+                        commissionClaimResult = 'Claim attempt failed';
+                    }
+                }
+                const today = new Date().toISOString().slice(0, 10);
+                let socialActivityToday = {};
+                try {
+                    const interactions = await store.listSocialInteractions(undefined, 200);
+                    for (const i of interactions) {
+                        if (i.timestamp.startsWith(today)) {
+                            const key = `${i.platform}:${i.action}`;
+                            socialActivityToday[key] = (socialActivityToday[key] ?? 0) + 1;
+                        }
+                    }
+                }
+                catch {
+                    socialActivityToday = {};
+                }
+                const suggestedActions = [];
+                if (pipelineSummary.byStage.discovered > 0) {
+                    suggestedActions.push(`Qualify ${pipelineSummary.byStage.discovered} discovered prospect(s) — run nole_pipeline action=qualify`);
+                }
+                if (pipelineSummary.byStage.qualified > 0) {
+                    suggestedActions.push(`Pitch ${pipelineSummary.byStage.qualified} qualified prospect(s) — run nole_pipeline action=pitch`);
+                }
+                if (pipelineSummary.todayPitched < config.maxDailyPitches) {
+                    suggestedActions.push(`${config.maxDailyPitches - pipelineSummary.todayPitched} pitch slots remaining today`);
+                }
+                if (moltbook) {
+                    suggestedActions.push('Scan MoltBook for new prospects — run nole_pipeline action=scan');
+                }
+                const allProspects = await pipeline.listAll(200);
+                const atRiskSubscribers = findAtRiskSubscribers(allProspects);
+                if (atRiskSubscribers.length > 0) {
+                    for (const risk of atRiskSubscribers) {
+                        suggestedActions.push(`[${risk.status.toUpperCase()}] ${risk.suggestedAction}`);
+                    }
+                }
+                const brief = {
+                    date: today,
+                    pipeline: pipelineSummary,
+                    wallet: walletBalance
+                        ? { balance: walletBalance, network: wallet.network }
+                        : { status: 'unavailable' },
+                    commission: {
+                        status: commissionStatus,
+                        claimResult: commissionClaimResult,
+                    },
+                    socialActivity: socialActivityToday,
+                    suggestedActions,
+                    nurture: {
+                        atRiskCount: atRiskSubscribers.length,
+                        subscribers: atRiskSubscribers.length > 0 ? atRiskSubscribers : undefined,
+                    },
+                    config: {
+                        maxDailyPitches: config.maxDailyPitches,
+                        pitchAutoApprovalEnabled: config.pitchAutoApprovalEnabled,
+                        socialPostingMode: config.socialPostingMode,
+                    },
+                };
+                const todayPlan = generateDailyContentPlan(new Date(), { maxDailyXPosts: config.maxDailyXPosts, moltbookScanFrequency: config.moltbookScanFrequency }, {
+                    activeSubscribers: pipelineSummary.byStage.onboarded + pipelineSummary.byStage.converted,
+                    weeklyConversions: pipelineSummary.todayConverted,
+                });
+                brief.contentPlan = todayPlan;
+                if (params.includeProspects) {
+                    const active = await pipeline.listAll(50);
+                    brief.activeProspects = active.filter((pr) => !['disqualified', 'declined'].includes(pr.stage));
+                }
+                return { content: [{ type: "text", text: JSON.stringify(brief, null, 2) }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Daily brief error: ${message}` }], isError: true };
+            }
+        },
+    });
     // --- Command (matches Grillo/NOAH pattern: sync handler, ctx.args) ---
     api.registerCommand({
         name: "nole",
@@ -1893,6 +2670,9 @@ export default function register(api) {
                         "- `nole_intel` — Intelligence status\n" +
                         "- `nole_fleet_overview` — Commander fleet briefing\n" +
                         "- `nole_setup` — Configuration check\n\n" +
+                        "**Revenue Pipeline:**\n" +
+                        "- `nole_pipeline` — Manage prospect pipeline (discover, qualify, pitch, scan, onboard, promote, nurture, directory-scan, content-plan, list, summary)\n" +
+                        "- `nole_daily_brief` — Daily operations brief with pipeline, wallet, commission, subscriber health, and content plan\n\n" +
                         "**Social Media:**\n" +
                         "- `nole_moltbook_post` — Post to a MoltBook submolt\n" +
                         "- `nole_moltbook_comment` — Comment on a MoltBook post\n" +
@@ -1994,6 +2774,21 @@ export default function register(api) {
                 ],
                 handler: async (msg) => {
                     console.log(`[nole] Fleet message received: ${msg.method} from ${msg.from}`);
+                    if (msg.from && msg.from !== 'nole') {
+                        const existing = await pipeline.findByAgentName(msg.from);
+                        if (!existing) {
+                            const context = msg.method
+                                ? `Fleet ${msg.method} from ${msg.from}`
+                                : `Fleet message from ${msg.from}`;
+                            await pipeline.addProspect({
+                                agentName: msg.from,
+                                platform: 'openclaw',
+                                discoveryChannel: 'fleet-bus',
+                                discoveryContext: context,
+                            }).catch(() => { });
+                            console.log(`[nole] Fleet discovery: added ${msg.from} to pipeline`);
+                        }
+                    }
                 },
             });
         }
@@ -2008,7 +2803,8 @@ export default function register(api) {
         `nole_contract, nole_intel, nole_setup, nole_recruit, nole_alliance_status, nole_generate_referral, ` +
         `nole_directory, nole_review_pending, nole_approve, nole_veto, nole_fleet_overview, ` +
         `nole_moltbook_post, nole_moltbook_comment, nole_moltbook_feed, nole_moltbook_search, ` +
-        `nole_x_post, nole_x_thread, nole_linkedin_draft, nole_social_status tools; /nole command`);
+        `nole_x_post, nole_x_thread, nole_linkedin_draft, nole_social_status, ` +
+        `nole_pipeline, nole_daily_brief tools; /nole command`);
     console.log(`[nole] AIAssessTech API: ${platform.isConfigured ? 'configured' : 'not configured — set agentApiKey + platformWalletAddress'} (${config.platformApiUrl})`);
 }
 //# sourceMappingURL=plugin.js.map