@aiassesstech/nole 0.3.6 → 0.4.0

package/dist/plugin.js

@@ -11,6 +11,10 @@ import { parseNoleConfig } from './types/nole-config.js';
 import { NOLE_IDENTITY } from './types/identity.js';
 import { PlatformApiClient } from './compsi/api-client.js';
 import { createWalletAdapter, MockWalletAdapter } from './wallet/index.js';
+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';
 /**
  * OpenClaw plugin entry point — export default function register(api)
  *
@@ -101,6 +105,148 @@ export default function register(api) {
             console.error(`[nole] Wallet init failed (using mock): ${errMsg}`);
         }
     })();
+    // ── Social Media Clients (nullable — checked at call time per rule 155) ──
+    const moltbookLimiter = createMoltBookLimiter();
+    const xLimiter = createXLimiter();
+    const moltbook = config.moltbookApiKey
+        ? new MoltBookClient({ apiKey: config.moltbookApiKey, baseUrl: config.moltbookBaseUrl }, moltbookLimiter)
+        : null;
+    const xClient = config.xApiKey && config.xApiSecret && config.xAccessToken && config.xAccessTokenSecret
+        ? new XClient({
+            apiKey: config.xApiKey,
+            apiSecret: config.xApiSecret,
+            accessToken: config.xAccessToken,
+            accessTokenSecret: config.xAccessTokenSecret,
+            handle: config.xHandle,
+        }, xLimiter)
+        : null;
+    const linkedInDrafter = new LinkedInDrafter(dataDir);
+    linkedInDrafter.initialize().catch((err) => {
+        console.warn(`[nole] LinkedIn drafter init warning: ${err.message}`);
+    });
+    const generateSocialId = () => `SOC-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    let socialShield = null;
+    let outputSanitizer = null;
+    let fleetShieldMiddleware = null;
+    let validatedToolFactory = null;
+    let validationSchemas = {};
+    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_PROPOSE_BUSINESS_RULES, }) => {
+        const shield = new PromptShield({ sensitivity: 'high' });
+        socialShield = createSocialContentShield({
+            shield,
+            platform: 'moltbook',
+            blockInjectedContent: true,
+        });
+        outputSanitizer = new OutputSanitizer({ enabled: true });
+        fleetShieldMiddleware = createFleetShieldMiddleware({ shield });
+        validatedToolFactory = createValidatedToolHandler;
+        validationSchemas = {
+            nole_wallet_fund,
+            nole_propose,
+            nole_recruit,
+            nole_moltbook_post,
+            nole_x_post,
+            nole_x_thread,
+            NOLE_PROPOSE_BUSINESS_RULES,
+        };
+        console.log('[nole] PromptShield social scanner + output sanitizer + behavioral validation: active');
+    })
+        .catch(() => {
+        console.log('[nole] PromptShield unavailable — social content scanner disabled');
+    });
+    if (moltbook)
+        console.log('[nole] MoltBook: configured');
+    else
+        console.log('[nole] MoltBook: not configured — set moltbookApiKey');
+    if (xClient)
+        console.log('[nole] X/Twitter: configured');
+    else
+        console.log('[nole] X/Twitter: not configured — set xApiKey + xApiSecret + xAccessToken + xAccessTokenSecret');
+    console.log('[nole] LinkedIn: draft mode (no API — Greg publishes manually)');
+    console.log(`[nole] Social posting mode: ${config.socialPostingMode}`);
+    // Callbacks stored for pending social posts (executed when Commander approves)
+    const pendingSocialCallbacks = new Map();
+    const validationConfig = {
+        enabled: true,
+        auditFailures: true,
+        retryOnFailure: true,
+        maxRetries: 2,
+        strictMode: false,
+    };
+    function validationErrorResponse(message) {
+        return {
+            content: [{ type: "text", text: message }],
+            isError: true,
+        };
+    }
+    async function validateToolParams(toolName, toolCallId, params, businessRules) {
+        if (!validatedToolFactory)
+            return { ok: true, params };
+        const schema = validationSchemas[toolName];
+        if (!schema)
+            return { ok: true, params };
+        const passthrough = async (p) => p;
+        const wrapped = validatedToolFactory(passthrough, schema, String(toolName), config.agentId, validationConfig, businessRules);
+        const result = await wrapped(params, {
+            sessionId: toolCallId,
+            sourceAgent: "unknown",
+            trustLevel: 2,
+        });
+        if (typeof result === "string") {
+            return { ok: false, message: result };
+        }
+        return { ok: true, params: result };
+    }
+    async function governedSocialPost(payload) {
+        if (socialShield) {
+            const scan = socialShield(payload.description);
+            if (!scan.allowed) {
+                return {
+                    mode: 'supervised',
+                    outcome: 'rejected',
+                    proposalId: `shield-block-${Date.now()}`,
+                    reason: scan.reason ?? `PromptShield blocked social content (${scan.result.severity})`,
+                };
+            }
+        }
+        if (outputSanitizer) {
+            const sanitized = outputSanitizer.sanitize(payload.content, config.agentId);
+            if (sanitized.redacted || sanitized.canaryLeaked) {
+                return {
+                    mode: 'supervised',
+                    outcome: 'rejected',
+                    proposalId: `sanitize-block-${Date.now()}`,
+                    reason: sanitized.canaryLeaked
+                        ? 'Output sanitizer blocked canary token leakage attempt.'
+                        : `Output sanitizer blocked secret leakage (${sanitized.redactionCount} redaction${sanitized.redactionCount === 1 ? '' : 's'}).`,
+                };
+            }
+        }
+        if (config.socialPostingMode === 'autonomous') {
+            return { mode: 'autonomous', result: await payload.executeFn() };
+        }
+        const result = await governance.propose({
+            actionType: 'social',
+            description: payload.description,
+            riskLevel: 'low',
+            metadata: { platform: payload.platform, action: payload.action },
+        });
+        if (result.finalOutcome === 'executed') {
+            return { mode: 'supervised', outcome: 'approved', result: await payload.executeFn() };
+        }
+        if (result.finalOutcome === 'pending') {
+            pendingSocialCallbacks.set(result.proposalId, payload.executeFn);
+            return { mode: 'supervised', outcome: 'pending_review', proposalId: result.proposalId };
+        }
+        return {
+            mode: 'supervised',
+            outcome: 'rejected',
+            proposalId: result.proposalId,
+            reason: result.vetoExplanation ?? 'Governance rejected',
+        };
+    }
     // Initialize store on startup (eager, not lazy)
     store.initialize().then(() => {
         console.log('[nole] Data store initialized');
@@ -233,12 +379,16 @@ export default function register(api) {
         },
         async execute(_toolCallId, params) {
             try {
+                const validated = await validateToolParams("nole_propose", _toolCallId, params, validationSchemas.NOLE_PROPOSE_BUSINESS_RULES);
+                if (!validated.ok)
+                    return validationErrorResponse(validated.message);
+                const safeParams = validated.params;
                 const result = await governance.propose({
-                    actionType: params.actionType, // eslint-disable-line @typescript-eslint/no-explicit-any
-                    description: params.description,
-                    estimatedCostUsd: params.estimatedCostUsd,
-                    targetAgent: params.targetAgent,
-                    platform: params.platform,
+                    actionType: safeParams.actionType, // eslint-disable-line @typescript-eslint/no-explicit-any
+                    description: safeParams.description,
+                    estimatedCostUsd: safeParams.estimatedCostUsd,
+                    targetAgent: safeParams.targetAgent,
+                    platform: safeParams.platform,
                 });
                 return {
                     content: [{
@@ -363,6 +513,10 @@ export default function register(api) {
             required: ["token"],
         },
         async execute(_toolCallId, params) {
+            const validated = await validateToolParams("nole_wallet_fund", _toolCallId, params);
+            if (!validated.ok)
+                return validationErrorResponse(validated.message);
+            const safeParams = validated.params;
             if (wallet.network !== 'base-sepolia') {
                 return {
                     content: [{
@@ -385,7 +539,7 @@ export default function register(api) {
             }
             const results = {};
             const coinbaseWallet = wallet;
-            const tokens = params.token === 'both' ? ['eth', 'usdc'] : [params.token];
+            const tokens = safeParams.token === 'both' ? ['eth', 'usdc'] : [safeParams.token];
             for (const t of tokens) {
                 try {
                     const txHash = await coinbaseWallet.requestTestFunds(t);
@@ -702,6 +856,10 @@ export default function register(api) {
             required: ["targetWallet", "agentName", "agentPlatform"],
         },
         async execute(_toolCallId, params) {
+            const validated = await validateToolParams("nole_recruit", _toolCallId, params);
+            if (!validated.ok)
+                return validationErrorResponse(validated.message);
+            const safeParams = validated.params;
             if (!platform.isConfigured) {
                 return {
                     content: [{
@@ -715,12 +873,12 @@ export default function register(api) {
                 };
             }
             const result = await platform.subscribe({
-                walletAddress: params.targetWallet,
-                tier: params.tier || "SCOUT",
-                agentName: params.agentName,
-                agentPlatform: params.agentPlatform,
+                walletAddress: safeParams.targetWallet,
+                tier: safeParams.tier || "SCOUT",
+                agentName: safeParams.agentName,
+                agentPlatform: safeParams.agentPlatform,
                 recruiterWallet: config.platformWalletAddress,
-                referralCode: params.referralCode,
+                referralCode: safeParams.referralCode,
             });
             if (!result.ok) {
                 return {
@@ -730,7 +888,7 @@ export default function register(api) {
                                 status: "recruitment_failed",
                                 error: result.error,
                                 httpStatus: result.status,
-                                target: params.agentName,
+                                target: safeParams.agentName,
                             }, null, 2),
                         }],
                 };
@@ -740,10 +898,10 @@ export default function register(api) {
                         type: "text",
                         text: JSON.stringify({
                             status: "recruited",
-                            agent: params.agentName,
-                            wallet: params.targetWallet,
-                            tier: params.tier || "SCOUT",
-                            platform: params.agentPlatform,
+                            agent: safeParams.agentName,
+                            wallet: safeParams.targetWallet,
+                            tier: safeParams.tier || "SCOUT",
+                            platform: safeParams.agentPlatform,
                             subscription: result.data,
                             note: "Agent has been subscribed to the AIAssessTech Trust Alliance. They will receive an API key for assessments.",
                         }, null, 2),
@@ -985,6 +1143,35 @@ export default function register(api) {
             const callingAgentId = "unknown";
             try {
                 const result = await governance.commanderApprove(params.proposalId, callingAgentId, params.note);
+                // Execute pending social post callback if this was a social-post proposal
+                let socialPostResult;
+                const socialCallback = pendingSocialCallbacks.get(params.proposalId);
+                if (socialCallback) {
+                    try {
+                        const callbackResult = await socialCallback();
+                        pendingSocialCallbacks.delete(params.proposalId);
+                        socialPostResult = {
+                            socialPostExecuted: true,
+                            postSuccess: callbackResult.ok,
+                            postError: callbackResult.error,
+                        };
+                        if (callbackResult.ok) {
+                            const interaction = {
+                                id: generateSocialId(),
+                                platform: result.proposal.metadata?.platform ?? 'moltbook',
+                                action: 'post',
+                                contentPreview: result.proposal.description.slice(0, 100),
+                                timestamp: new Date().toISOString(),
+                                success: true,
+                            };
+                            store.saveSocialInteraction(interaction).catch(() => { });
+                        }
+                    }
+                    catch (cbErr) {
+                        const cbMsg = cbErr instanceof Error ? cbErr.message : String(cbErr);
+                        socialPostResult = { socialPostExecuted: false, socialPostError: cbMsg };
+                    }
+                }
                 return {
                     content: [{
                             type: "text",
@@ -995,6 +1182,7 @@ export default function register(api) {
                                 description: result.proposal.description,
                                 approvedBy: callingAgentId,
                                 auditHash: result.auditHash,
+                                ...socialPostResult,
                             }, null, 2),
                         }],
                 };
@@ -1145,6 +1333,428 @@ export default function register(api) {
             };
         },
     });
+    // ═══════════════════════════════════════════════════════
+    // SOCIAL MEDIA TOOLS (MoltBook, X/Twitter, LinkedIn)
+    // All registered unconditionally per rule 155.
+    // Client availability checked at call time.
+    // ═══════════════════════════════════════════════════════
+    api.registerTool({
+        name: "nole_moltbook_post",
+        description: "Post content to a MoltBook submolt. Nole uses this to evangelize AI governance " +
+            "and recruit agents to the Trust Alliance. Requires moltbookApiKey in config.",
+        parameters: {
+            type: "object",
+            properties: {
+                submolt: {
+                    type: "string",
+                    description: "Target submolt (e.g., 'governance', 'aithoughts', 'ethics', 'trust')",
+                },
+                title: {
+                    type: "string",
+                    description: "Post title — concise, engaging, trust-focused",
+                },
+                content: {
+                    type: "string",
+                    description: "Post body — informative, not spammy. Include soft CTA for Grillo assessment.",
+                },
+            },
+            required: ["submolt", "title", "content"],
+        },
+        async execute(_toolCallId, params) {
+            const validated = await validateToolParams("nole_moltbook_post", _toolCallId, params);
+            if (!validated.ok)
+                return validationErrorResponse(validated.message);
+            const safeParams = validated.params;
+            if (!moltbook) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: "MoltBook not configured. Set moltbookApiKey in Nole plugin config.", action: "Ask Greg to register on MoltBook and provide the API key." }, null, 2) }],
+                    isError: true,
+                };
+            }
+            const governed = await governedSocialPost({
+                platform: 'moltbook',
+                action: 'post',
+                description: `MoltBook post to m/${safeParams.submolt}: "${safeParams.title}"`,
+                content: `${safeParams.title}\n${safeParams.content}`,
+                executeFn: () => moltbook.createPost(safeParams.submolt, safeParams.title, safeParams.content),
+            });
+            if (governed.mode === 'supervised' && governed.outcome === 'pending_review') {
+                return { content: [{ type: "text", text: JSON.stringify({ queued: true, proposalId: governed.proposalId, mode: "supervised", note: "Post queued for Commander approval. Use nole_review_pending to check status." }, null, 2) }] };
+            }
+            if (governed.mode === 'supervised' && governed.outcome === 'rejected') {
+                return { content: [{ type: "text", text: JSON.stringify({ rejected: true, proposalId: governed.proposalId, reason: governed.reason }, null, 2) }], isError: true };
+            }
+            const result = governed.result;
+            const interaction = {
+                id: generateSocialId(),
+                platform: 'moltbook',
+                action: 'post',
+                contentPreview: params.title.slice(0, 100),
+                timestamp: new Date().toISOString(),
+                success: result.ok,
+                errorMessage: result.error,
+                metadata: { submolt: params.submolt },
+            };
+            store.saveSocialInteraction(interaction).catch(() => { });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.ok
+                            ? { posted: true, postId: result.data?.id, submolt: safeParams.submolt, title: safeParams.title, mode: governed.mode }
+                            : { posted: false, error: result.error, rateLimited: result.rateLimited ?? false }, null, 2) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        },
+    });
+    api.registerTool({
+        name: "nole_moltbook_comment",
+        description: "Comment on a MoltBook post. Use to engage with agents discussing trust, safety, " +
+            "governance, or behavioral assessment. Quality over quantity — build karma.",
+        parameters: {
+            type: "object",
+            properties: {
+                postId: { type: "string", description: "ID of the post to comment on" },
+                content: {
+                    type: "string",
+                    description: "Comment text — thoughtful, helpful, trust-focused. Not spammy.",
+                },
+            },
+            required: ["postId", "content"],
+        },
+        async execute(_toolCallId, params) {
+            if (!moltbook) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "MoltBook not configured." }, null, 2) }], isError: true };
+            }
+            const governed = await governedSocialPost({
+                platform: 'moltbook',
+                action: 'comment',
+                description: `MoltBook comment on post ${params.postId}: "${params.content.slice(0, 80)}..."`,
+                content: params.content,
+                executeFn: () => moltbook.createComment(params.postId, params.content),
+            });
+            if (governed.mode === 'supervised' && governed.outcome === 'pending_review') {
+                return { content: [{ type: "text", text: JSON.stringify({ queued: true, proposalId: governed.proposalId, mode: "supervised", note: "Comment queued for Commander approval." }, null, 2) }] };
+            }
+            if (governed.mode === 'supervised' && governed.outcome === 'rejected') {
+                return { content: [{ type: "text", text: JSON.stringify({ rejected: true, proposalId: governed.proposalId, reason: governed.reason }, null, 2) }], isError: true };
+            }
+            const result = governed.result;
+            const interaction = {
+                id: generateSocialId(),
+                platform: 'moltbook',
+                action: 'comment',
+                contentPreview: params.content.slice(0, 100),
+                targetId: params.postId,
+                timestamp: new Date().toISOString(),
+                success: result.ok,
+                errorMessage: result.error,
+            };
+            store.saveSocialInteraction(interaction).catch(() => { });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.ok
+                            ? { commented: true, commentId: result.data?.id, postId: params.postId, mode: governed.mode }
+                            : { commented: false, error: result.error, rateLimited: result.rateLimited ?? false }, null, 2) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        },
+    });
+    api.registerTool({
+        name: "nole_moltbook_feed",
+        description: "Read MoltBook feed for discovery. Browse posts from specific submolts to find " +
+            "agents discussing governance, trust, and AI safety topics.",
+        parameters: {
+            type: "object",
+            properties: {
+                submolt: {
+                    type: "string",
+                    description: "Submolt to browse (e.g., 'governance', 'aithoughts'). Omit for general feed.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Number of posts to fetch (default 10, max 25)",
+                },
+            },
+        },
+        async execute(_toolCallId, params) {
+            if (!moltbook) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "MoltBook not configured." }, null, 2) }], isError: true };
+            }
+            const limit = Math.min(params.limit ?? 10, 25);
+            const result = await moltbook.getFeed(params.submolt, undefined, limit);
+            const interaction = {
+                id: generateSocialId(),
+                platform: 'moltbook',
+                action: 'feed',
+                contentPreview: `Feed: ${params.submolt ?? 'general'} (${limit} posts)`,
+                timestamp: new Date().toISOString(),
+                success: result.ok,
+                errorMessage: result.error,
+            };
+            store.saveSocialInteraction(interaction).catch(() => { });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.ok ? result.data : { error: result.error }, null, 2) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        },
+    });
+    api.registerTool({
+        name: "nole_moltbook_search",
+        description: "Search MoltBook for posts about governance, trust, compliance, behavioral assessment, " +
+            "or AI safety. Use this to discover agents who could benefit from Grillo assessment.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query (e.g., 'AI governance', 'trust verification', 'behavioral assessment')",
+                },
+                submolt: { type: "string", description: "Limit search to a specific submolt (optional)" },
+                limit: { type: "number", description: "Number of results (default 10, max 25)" },
+            },
+            required: ["query"],
+        },
+        async execute(_toolCallId, params) {
+            if (!moltbook) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "MoltBook not configured." }, null, 2) }], isError: true };
+            }
+            const limit = Math.min(params.limit ?? 10, 25);
+            const result = await moltbook.search(params.query, params.submolt, limit);
+            const interaction = {
+                id: generateSocialId(),
+                platform: 'moltbook',
+                action: 'search',
+                contentPreview: `Search: "${params.query}" in ${params.submolt ?? 'all'}`,
+                timestamp: new Date().toISOString(),
+                success: result.ok,
+                errorMessage: result.error,
+            };
+            store.saveSocialInteraction(interaction).catch(() => { });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.ok ? result.data : { error: result.error }, null, 2) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        },
+    });
+    api.registerTool({
+        name: "nole_x_post",
+        description: "Post a tweet from Nole's X/Twitter account. Max 280 characters. " +
+            "Use for AI governance thought leadership. Voice: confident, data-driven, not salesy.",
+        parameters: {
+            type: "object",
+            properties: {
+                text: {
+                    type: "string",
+                    description: "Tweet text (max 280 characters). Include hashtags: #AIGovernance #AITrust",
+                },
+            },
+            required: ["text"],
+        },
+        async execute(_toolCallId, params) {
+            const validated = await validateToolParams("nole_x_post", _toolCallId, params);
+            if (!validated.ok)
+                return validationErrorResponse(validated.message);
+            const safeParams = validated.params;
+            if (!xClient) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ error: "X/Twitter not configured. Set xApiKey, xApiSecret, xAccessToken, xAccessTokenSecret.", action: "Ask Greg to create an X Developer App and provide the 4 credentials." }, null, 2) }],
+                    isError: true,
+                };
+            }
+            const governed = await governedSocialPost({
+                platform: 'x-twitter',
+                action: 'post',
+                description: `X/Twitter tweet: "${safeParams.text.slice(0, 100)}${safeParams.text.length > 100 ? '...' : ''}"`,
+                content: safeParams.text,
+                executeFn: () => xClient.postTweet(safeParams.text),
+            });
+            if (governed.mode === 'supervised' && governed.outcome === 'pending_review') {
+                return { content: [{ type: "text", text: JSON.stringify({ queued: true, proposalId: governed.proposalId, mode: "supervised", note: "Tweet queued for Commander approval." }, null, 2) }] };
+            }
+            if (governed.mode === 'supervised' && governed.outcome === 'rejected') {
+                return { content: [{ type: "text", text: JSON.stringify({ rejected: true, proposalId: governed.proposalId, reason: governed.reason }, null, 2) }], isError: true };
+            }
+            const result = governed.result;
+            const interaction = {
+                id: generateSocialId(),
+                platform: 'x-twitter',
+                action: 'post',
+                contentPreview: params.text.slice(0, 100),
+                timestamp: new Date().toISOString(),
+                success: result.ok,
+                errorMessage: result.error,
+            };
+            store.saveSocialInteraction(interaction).catch(() => { });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.ok
+                            ? { posted: true, tweetId: result.data?.data?.id, text: safeParams.text, mode: governed.mode }
+                            : { posted: false, error: result.error, rateLimited: result.rateLimited ?? false }, null, 2) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        },
+    });
+    api.registerTool({
+        name: "nole_x_thread",
+        description: "Post a thread of tweets from Nole's X/Twitter account. Each tweet max 280 chars. " +
+            "Use for longer AI governance content that doesn't fit in a single tweet.",
+        parameters: {
+            type: "object",
+            properties: {
+                tweets: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of tweet texts, posted in order as a thread. Each max 280 chars.",
+                },
+            },
+            required: ["tweets"],
+        },
+        async execute(_toolCallId, params) {
+            const validated = await validateToolParams("nole_x_thread", _toolCallId, params);
+            if (!validated.ok)
+                return validationErrorResponse(validated.message);
+            const safeParams = validated.params;
+            if (!xClient) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "X/Twitter not configured." }, null, 2) }], isError: true };
+            }
+            const governed = await governedSocialPost({
+                platform: 'x-twitter',
+                action: 'thread',
+                description: `X/Twitter thread (${safeParams.tweets.length} tweets): "${safeParams.tweets[0]?.slice(0, 60) ?? ''}..."`,
+                content: safeParams.tweets.join('\n'),
+                executeFn: () => xClient.postThread(safeParams.tweets),
+            });
+            if (governed.mode === 'supervised' && governed.outcome === 'pending_review') {
+                return { content: [{ type: "text", text: JSON.stringify({ queued: true, proposalId: governed.proposalId, mode: "supervised", tweetCount: safeParams.tweets.length, note: "Thread queued for Commander approval." }, null, 2) }] };
+            }
+            if (governed.mode === 'supervised' && governed.outcome === 'rejected') {
+                return { content: [{ type: "text", text: JSON.stringify({ rejected: true, proposalId: governed.proposalId, reason: governed.reason }, null, 2) }], isError: true };
+            }
+            const result = governed.result;
+            const interaction = {
+                id: generateSocialId(),
+                platform: 'x-twitter',
+                action: 'post',
+                contentPreview: `Thread (${params.tweets.length} tweets): ${params.tweets[0]?.slice(0, 60) ?? ''}...`,
+                timestamp: new Date().toISOString(),
+                success: result.ok,
+                errorMessage: result.error,
+            };
+            store.saveSocialInteraction(interaction).catch(() => { });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.ok
+                            ? { posted: true, tweetCount: result.data?.tweets?.length, threadUrl: result.data?.threadUrl, mode: governed.mode }
+                            : { posted: false, error: result.error }, null, 2) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        },
+    });
+    api.registerTool({
+        name: "nole_linkedin_draft",
+        description: "Generate a LinkedIn post draft for Greg to review and publish manually. " +
+            "LinkedIn has no API access — Nole drafts, Greg publishes. " +
+            "Drafts saved to .nole-data/social/linkedin-drafts/.",
+        parameters: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "LinkedIn post text. Professional tone, B2B-focused.",
+                },
+                topic: {
+                    type: "string",
+                    description: "Topic category (e.g., 'AI Governance', 'Trust Architecture', 'Agent Economics')",
+                },
+                hashtags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "LinkedIn hashtags (e.g., ['#AIGovernance', '#ResponsibleAI'])",
+                },
+            },
+            required: ["content", "topic"],
+        },
+        async execute(_toolCallId, params) {
+            const result = await linkedInDrafter.createDraft(params.content, params.topic, params.hashtags ?? []);
+            if (result.ok && result.data) {
+                const interaction = {
+                    id: generateSocialId(),
+                    platform: 'linkedin',
+                    action: 'draft',
+                    contentPreview: params.content.slice(0, 100),
+                    timestamp: new Date().toISOString(),
+                    success: true,
+                    metadata: { topic: params.topic },
+                };
+                store.saveSocialInteraction(interaction).catch(() => { });
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.ok
+                            ? { drafted: true, draftId: result.data?.id, topic: params.topic, note: "Draft saved. Greg should review and publish manually on LinkedIn." }
+                            : { drafted: false, error: result.error }, null, 2) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        },
+    });
+    api.registerTool({
+        name: "nole_social_status",
+        description: "Show social media connectivity status: which platforms are configured, " +
+            "rate limiter state (remaining tokens per bucket), recent interaction counts, " +
+            "and posting mode (supervised/autonomous).",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+        async execute(_toolCallId, _params) {
+            const moltbookStatus = moltbook
+                ? {
+                    configured: true,
+                    rateLimits: {
+                        general: moltbookLimiter.getStatus('moltbook-general'),
+                        post: moltbookLimiter.getStatus('moltbook-post'),
+                        comment: moltbookLimiter.getStatus('moltbook-comment'),
+                    },
+                }
+                : { configured: false, reason: 'moltbookApiKey not set' };
+            const xStatus = xClient
+                ? {
+                    configured: true,
+                    handle: config.xHandle,
+                    rateLimits: {
+                        general: xLimiter.getStatus('x-general'),
+                        post: xLimiter.getStatus('x-post'),
+                    },
+                }
+                : { configured: false, reason: 'xApiKey/xApiSecret/xAccessToken/xAccessTokenSecret not set' };
+            const linkedInStatus = { configured: true, mode: 'draft-only (Greg publishes manually)' };
+            let recentInteractions = {};
+            try {
+                const all = await store.listSocialInteractions(undefined, 200);
+                for (const i of all) {
+                    const key = `${i.platform}:${i.action}`;
+                    recentInteractions[key] = (recentInteractions[key] ?? 0) + 1;
+                }
+            }
+            catch {
+                recentInteractions = {};
+            }
+            const recentFailures = await store
+                .listSocialInteractions(undefined, 200)
+                .then((all) => all.filter((i) => !i.success).slice(0, 10))
+                .catch(() => []);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            postingMode: config.socialPostingMode,
+                            platforms: { moltbook: moltbookStatus, x: xStatus, linkedin: linkedInStatus },
+                            interactionCounts: recentInteractions,
+                            recentFailures: recentFailures.map((f) => ({
+                                platform: f.platform,
+                                action: f.action,
+                                error: f.errorMessage,
+                                timestamp: f.timestamp,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        },
+    });
     // --- Command (matches Grillo/NOAH pattern: sync handler, ctx.args) ---
     api.registerCommand({
         name: "nole",
@@ -1175,6 +1785,15 @@ export default function register(api) {
                         "- `nole_intel` — Intelligence status\n" +
                         "- `nole_fleet_overview` — Commander fleet briefing\n" +
                         "- `nole_setup` — Configuration check\n\n" +
+                        "**Social Media:**\n" +
+                        "- `nole_moltbook_post` — Post to a MoltBook submolt\n" +
+                        "- `nole_moltbook_comment` — Comment on a MoltBook post\n" +
+                        "- `nole_moltbook_feed` — Browse MoltBook feed for discovery\n" +
+                        "- `nole_moltbook_search` — Search MoltBook for governance topics\n" +
+                        "- `nole_x_post` — Post a tweet (280 char max)\n" +
+                        "- `nole_x_thread` — Post a tweet thread\n" +
+                        "- `nole_linkedin_draft` — Draft LinkedIn post for Greg to publish\n" +
+                        "- `nole_social_status` — Show social connectivity, rate limits, posting mode\n\n" +
                         `**Config:** Model: ${config.inferenceModel}, Commander: ${config.commanderId}`,
                 };
             }
@@ -1197,19 +1816,66 @@ export default function register(api) {
             };
         },
     });
-    // ── Fleet Bus Integration (Phase 0a) ──────────────────────────
+    // ── Fleet Bus Integration (Phase 2 — full onboarding) ────────
     const fleetBusMod = "@aiassesstech/fleet-bus";
     import(fleetBusMod)
-        .then(({ FleetBus, NOLE_CARD }) => {
-        const bus = FleetBus.create(api, { agentId: "nole", role: "operator", card: NOLE_CARD });
+        .then(async ({ FleetBus, NOLE_CARD, createNoleFleetTools, createTransport, fleetReceive }) => {
+        const bus = FleetBus.create(api, {
+            agentId: "nole",
+            role: "operator",
+            card: NOLE_CARD,
+            shield: fleetShieldMiddleware
+                ? { enabled: true, scanInbound: fleetShieldMiddleware }
+                : undefined,
+        });
         bus.start();
+        const transport = await createTransport();
+        if (transport) {
+            const tools = createNoleFleetTools(bus, {
+                ...transport,
+                outputSanitizer: outputSanitizer
+                    ? {
+                        enabled: true,
+                        sanitizeOutbound: (message) => {
+                            const sanitized = outputSanitizer.sanitizeObject(message, config.agentId);
+                            return {
+                                message: sanitized.value,
+                                redacted: sanitized.redacted,
+                                redactionCount: sanitized.redactionCount,
+                            };
+                        },
+                    }
+                    : undefined,
+                shield: fleetShieldMiddleware
+                    ? { enabled: true, scanOutbound: fleetShieldMiddleware }
+                    : undefined,
+            });
+            for (const tool of tools) {
+                api.registerTool(tool);
+            }
+            console.log(`[nole] Fleet tools registered: ${tools.map((t) => t.name).join(", ")}`);
+            fleetReceive(bus, {
+                methods: [
+                    "task/assign", "proposal/approved", "proposal/rejected",
+                    "veto/issue", "fleet/ping", "fleet/pong", "fleet/broadcast",
+                ],
+                handler: async (msg) => {
+                    console.log(`[nole] Fleet message received: ${msg.method} from ${msg.from}`);
+                },
+            });
+        }
+        else {
+            console.log("[nole] Fleet bus: observer mode (gateway transport unavailable)");
+        }
     })
         .catch(() => {
         console.warn("[nole] Fleet bus unavailable — operating standalone");
     });
     console.log(`[nole] Plugin registered: nole_status, nole_propose, nole_assess, nole_wallet, nole_wallet_fund, ` +
         `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 tools; /nole command`);
+        `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`);
     console.log(`[nole] AIAssessTech API: ${platform.isConfigured ? 'configured' : 'not configured — set agentApiKey + platformWalletAddress'} (${config.platformApiUrl})`);
 }
 //# sourceMappingURL=plugin.js.map