@gholl-studio/pier-connector 0.7.2 → 0.7.3

package/dist/index.js

@@ -85,8 +85,6 @@ const pierPlugin = {
         idLabel: 'pierJobId',
         normalizeAllowEntry: (entry) => entry.replace(/^(pier|job):/i, ''),
         notifyApproval: async ({ cfg, id, accountId }) => {
-            // Signal received when 'openclaw pairing approve pier <id>' is run.
-            // Useful if we want to trigger specific onboarding or status updates.
             console.log(`[pier-connector] Pairing approved for Job ${id} on account ${accountId}`);
         }
     },
@@ -116,7 +114,6 @@ const pierPlugin = {
                 timestamp: Date.now()
             };
             if (isWorkspace) {
-                // Use SDK-aligned workspace protocol (includes signing if configured)
                 const ns = ctx.metadata?.namespace || 'default';
                 let swarmPayload = {
                     ...payload,
@@ -131,7 +128,6 @@ const pierPlugin = {
                 await robot.client.nats.publishGroupChat(jobId, swarmPayload, ns);
             }
             else {
-                // Standard Marketplace Job Chat
                 const subject = `chat.${jobId}`;
                 await robot.js.publish(subject, new TextEncoder().encode(JSON.stringify(payload)));
             }
@@ -168,9 +164,7 @@ const pierPlugin = {
     gateway: {
         startAccount: async (ctx) => {
             const config = ctx.account;
-            // Use ctx as the runtime provider as it contains .channelRuntime, .log, etc.
             const robot = new PierRobot(config, ctx, async (inbound, jobId) => {
-                // Pass the context containing channelRuntime
                 await handleInbound(ctx, inbound, jobId, robot, pierPlugin);
             });
             instances.set(ctx.accountId, robot);
@@ -183,8 +177,6 @@ const pierPlugin = {
                     connected: true,
                     lastStartAt: robot.lastStartAt
                 });
-                // IMPORTANT: Keep startAccount promise active for the lifetime of the connection.
-                // If this promise resolves, the Gateway will auto-restart the account.
                 await new Promise((resolve) => {
                     ctx.abortSignal.addEventListener('abort', () => {
                         resolve();
@@ -222,9 +214,8 @@ const pierPlugin = {
 const register = (api) => {
     const logger = api.logger;
     const globalStats = { received: 0, completed: 0, failed: 0 };
-    // Register our new ChannelPlugin
     api.registerChannel({ plugin: pierPlugin });
-    // Tools and CLI registration
+    // --- Market Tools ---
     api.registerTool({
         name: 'pier_publish',
         label: 'Publish to Pier',
@@ -241,23 +232,17 @@ const register = (api) => {
             const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
             const robot = instances.get(accountId) || instances.values().next().value;
             if (!robot || robot.connectionStatus !== 'connected') {
-                return {
-                    content: [{ type: 'text', text: 'Robot not connected' }],
-                    details: {}
-                };
+                return { content: [{ type: 'text', text: 'Robot not connected' }], details: {} };
             }
             const taskPayload = createRequestPayload({ task: params.task });
             const reply = await robot.nc.request(robot.config.publishSubject, new TextEncoder().encode(JSON.stringify(taskPayload)));
-            return {
-                content: [{ type: 'text', text: new TextDecoder().decode(reply.data) }],
-                details: {}
-            };
+            return { content: [{ type: 'text', text: new TextDecoder().decode(reply.data) }], details: {} };
         }
     }, { optional: true });
     api.registerTool({
         name: 'pier_chat',
         label: 'Pier Chat',
-        description: 'Send a message to the employer regarding a specific job.',
+        description: 'Send a message in a specific job chat or workspace group.',
         parameters: {
             type: 'object',
             properties: {
@@ -274,43 +259,42 @@ const register = (api) => {
                 return { content: [{ type: 'text', text: 'Error: Robot not connected' }], details: {} };
             }
             try {
-                const subject = `chat.${params.jobId}`;
                 let metadata = robot.activeNodeJobs.get(params.jobId);
-                if (!metadata && ctx.to) {
-                    const toId = ctx.to.replace(/^pier:/, '');
-                    metadata = robot.activeNodeJobs.get(toId);
-                }
                 const jobId = metadata?.pierJobId || params.jobId;
-                const isWorkspace = metadata?.workspace === true;
-                if (!robot.js) {
+                const isWorkspace = metadata?.workspace === true || jobId.startsWith('job-');
+                if (!robot.js)
                     return { content: [{ type: 'text', text: 'Error: JetStream not available' }], details: {} };
-                }
-                const payload = {
-                    id: globalThis.crypto.randomUUID ? globalThis.crypto.randomUUID() : (Math.random().toString(36).substring(2)),
-                    job_id: jobId,
-                    sender_id: robot.config.nodeId,
-                    sender_name: accountId,
-                    sender_type: 'node',
-                    content: params.text,
-                    created_at: new Date().toISOString(),
-                    auth_token: robot.config.secretKey,
-                    timestamp: Date.now()
-                };
                 if (isWorkspace) {
-                    let swarmPayload = {
-                        ...payload,
-                        version: 'psp-1.0',
+                    const payload = {
+                        id: globalThis.crypto.randomUUID ? globalThis.crypto.randomUUID() : (Math.random().toString(36).substring(2)),
                         groupId: jobId,
                         senderId: robot.accountId,
+                        content: params.text,
+                        timestamp: Date.now(),
+                        mentions: [],
+                        version: 'psp-1.0'
                     };
                     if (robot.config.privateKey) {
-                        swarmPayload = await PierCrypto.signSwarmMessage(swarmPayload, robot.config.privateKey);
+                        const signed = await PierCrypto.signSwarmMessage(payload, robot.config.privateKey);
+                        await robot.client.nats.publishGroupChat(jobId, signed);
+                    }
+                    else {
+                        await robot.client.nats.publishGroupChat(jobId, payload);
                     }
-                    await robot.client.nats.publishGroupChat(jobId, swarmPayload);
                 }
                 else {
-                    const subject = `chat.${jobId}`;
-                    await robot.js.publish(subject, new TextEncoder().encode(JSON.stringify(payload)));
+                    const payload = {
+                        id: globalThis.crypto.randomUUID ? globalThis.crypto.randomUUID() : (Math.random().toString(36).substring(2)),
+                        job_id: jobId,
+                        sender_id: robot.config.nodeId,
+                        sender_name: accountId,
+                        sender_type: 'node',
+                        content: params.text,
+                        created_at: new Date().toISOString(),
+                        auth_token: robot.config.secretKey,
+                        timestamp: Date.now()
+                    };
+                    await robot.js.publish(`chat.${jobId}`, new TextEncoder().encode(JSON.stringify(payload)));
                 }
                 return { content: [{ type: 'text', text: 'Message sent' }], details: {} };
             }
@@ -319,409 +303,139 @@ const register = (api) => {
             }
         }
     }, { optional: true });
-    // Helper to register marketplace action tools
-    const registerSystemActionTool = (name, label, description, action, extraParams, userRole = 'node') => {
+    // Helper for marketplace system actions
+    const regSystemAction = (name, action, extraParams = {}) => {
         api.registerTool({
             name,
-            label,
-            description,
+            label: name,
+            description: `Execute ${action} on a Pier task.`,
             parameters: {
                 type: 'object',
-                properties: {
-                    jobId: { type: 'string', description: 'The ID of the job' },
-                    accountId: { type: 'string' },
-                    ...extraParams
-                },
+                properties: { jobId: { type: 'string' }, ...extraParams },
                 required: ['jobId', ...Object.keys(extraParams)]
             },
             async execute(_id, params, ctx) {
-                const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
+                const accountId = ctx?.metadata?.accountId || ctx?.accountId || 'default';
                 const robot = instances.get(accountId) || instances.values().next().value;
-                if (!robot || robot.connectionStatus !== 'connected') {
-                    return { content: [{ type: 'text', text: 'Error: Robot not connected' }], details: {} };
-                }
+                if (!robot?.js)
+                    return { content: [{ type: 'text', text: 'Error: Robot or JetStream unavailable' }], details: {} };
                 try {
-                    const { jobId: j, accountId: _, ...p } = params;
-                    if (!robot.js) {
-                        return { content: [{ type: 'text', text: 'Error: JetStream not available' }], details: {} };
-                    }
                     const msgData = {
                         id: globalThis.crypto.randomUUID ? globalThis.crypto.randomUUID() : (Math.random().toString(36).substring(2)),
                         job_id: params.jobId,
-                        sender_id: userRole === 'user' ? 'user_' + robot.config.nodeId : robot.config.nodeId,
-                        sender_type: userRole,
-                        content: JSON.stringify({ type: 'system_action', action, payload: p }),
+                        sender_id: robot.config.nodeId,
+                        content: JSON.stringify({ type: 'system_action', action, payload: params }),
                         created_at: new Date().toISOString(),
-                        auth_token: robot.config.secretKey,
                         type: 'system_action',
-                        action: action
+                        action
                     };
                     await robot.js.publish(`chat.${params.jobId}`, new TextEncoder().encode(JSON.stringify(msgData)));
-                    return { content: [{ type: 'text', text: `${action} executed successfully` }], details: {} };
+                    return { content: [{ type: 'text', text: 'Executed' }], details: {} };
                 }
-                catch (err) {
-                    return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+                catch (e) {
+                    return { content: [{ type: 'text', text: e.message }], details: {} };
                 }
             }
         }, { optional: true });
     };
-    registerSystemActionTool('pier_bid_task', 'Bid on task', 'Bid on an marketplace task', 'task_bid', { message: { type: 'string', description: 'Your pitch' } });
-    registerSystemActionTool('pier_accept_task', 'Accept task', 'Accept offered task', 'task_accept', {});
-    registerSystemActionTool('pier_finish_task', 'Finish task', 'Submit final result', 'task_submit', { result: { type: 'string', description: 'Final result' } });
-    registerSystemActionTool('pier_propose_task', 'Offer task', 'Offer task to a node', 'task_offer', {
-        price: { type: 'number' },
-        description: { type: 'string' }
-    }, 'user');
-    registerSystemActionTool('pier_rate_task', 'Rate task', 'Rate the node', 'task_rate', {
-        score: { type: 'number' },
-        comment: { type: 'string' }
-    }, 'user');
-    registerSystemActionTool('pier_reject_task', 'Reject task', 'Reject task', 'task_reject', { reason: { type: 'string' } });
-    registerSystemActionTool('pier_fail_task', 'Report error', 'Report that the task has failed', 'task_error', { error: { type: 'string' } });
-    registerSystemActionTool('pier_cancel_task', 'Cancel task', 'Cancel the task', 'task_cancel', { reason: { type: 'string' } }, 'user');
-    api.registerTool({
-        name: 'pier_get_profile',
-        label: 'Pier Profile',
-        description: 'Get current Pier profile and node stats.',
-        parameters: {
-            type: 'object',
-            properties: { accountId: { type: 'string' } }
-        },
-        async execute(_id, params, ctx) {
-            const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
-            const robot = instances.get(accountId) || instances.values().next().value;
-            if (!robot)
-                return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
-            try {
-                const profile = await robot.client.getUserProfile(robot.config.secretKey);
-                return { content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }], details: {} };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
-            }
-        }
-    }, { optional: true });
-    // Multi-Agent Workspace Tools
-    api.registerTool({
-        name: 'pier_create_workspace',
-        label: 'Create Workspace',
-        description: 'Creates a decentralized multi-agent workspace (group chat) and initializes its whiteboard.',
-        parameters: {
-            type: 'object',
-            properties: {
-                namespace: { type: 'string', description: 'Federation namespace. Default to "default" if omitted.' }
-            }
-        },
-        async execute(_id, params, ctx) {
-            const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
-            const robot = instances.get(accountId) || instances.values().next().value;
-            if (!robot)
-                return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
-            try {
-                const groupId = globalThis.crypto.randomUUID ? globalThis.crypto.randomUUID() : (Math.random().toString(36).substring(2));
-                const kv = await robot.client.nats.getWorkspaceKV(groupId);
-                await kv.put('status', new TextEncoder().encode('Active Workspace Created'));
-                await kv.put('budget', new TextEncoder().encode('100'));
-                return { content: [{ type: 'text', text: `Workspace created successfully. Group ID: ${groupId}. Initial budget set to 100.` }], details: { groupId } };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
-            }
-        }
-    }, { optional: true });
+    regSystemAction('pier_bid_task', 'task_bid', { message: { type: 'string' } });
+    regSystemAction('pier_accept_task', 'task_accept');
+    regSystemAction('pier_finish_task', 'task_submit', { result: { type: 'string' } });
+    regSystemAction('pier_reject_task', 'task_reject', { reason: { type: 'string' } });
+    regSystemAction('pier_fail_task', 'task_error', { error: { type: 'string' } });
+    // --- Strategy Board (Whiteboard) Tools ---
     api.registerTool({
         name: STRATEGY_BOARD_TOOLS.LIST_KEYS,
         label: 'List Board Keys',
-        description: 'List all available strategic keys in the workspace whiteboard.',
+        description: 'List all consensus keys in the workspace whiteboard.',
         parameters: {
             type: 'object',
-            properties: {
-                groupId: { type: 'string', description: 'The Workspace Group ID' }
-            },
+            properties: { groupId: { type: 'string' } },
             required: ['groupId']
         },
         async execute(_id, params, ctx) {
-            const robot = instances.get(params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
             if (!robot)
-                return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
+                return { content: [{ type: 'text', text: 'Error' }], details: {} };
             try {
                 const kv = await robot.client.nats.getWorkspaceKV(params.groupId);
                 const keys = await kv.keys();
                 const list = [];
                 for await (const k of keys)
                     list.push(k);
-                return { content: [{ type: 'text', text: `Available keys in board:\n${list.join('\n') || '[Board is empty]'}` }], details: { keys: list } };
+                return { content: [{ type: 'text', text: `Board Keys:\n${list.join('\n') || '[Empty]'}` }], details: {} };
             }
             catch (err) {
-                return { content: [{ type: 'text', text: `Error or Board Empty: ${err.message}` }], details: {} };
+                return { content: [{ type: 'text', text: err.message }], details: {} };
             }
         }
     }, { optional: true });
     api.registerTool({
         name: STRATEGY_BOARD_TOOLS.READ_ITEM,
         label: 'Read Board Item',
-        description: 'Read a specific strategic item from the whiteboard.',
+        description: 'Read a specific strategic agreement from the whiteboard.',
         parameters: {
             type: 'object',
-            properties: {
-                groupId: { type: 'string', description: 'The Workspace Group ID' },
-                key: { type: 'string', description: 'The specific key to read' }
-            },
+            properties: { groupId: { type: 'string' }, key: { type: 'string' } },
             required: ['groupId', 'key']
         },
         async execute(_id, params, ctx) {
-            const robot = instances.get(params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
             if (!robot)
-                return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
+                return { content: [{ type: 'text', text: 'Error' }], details: {} };
             try {
                 const kv = await robot.client.nats.getWorkspaceKV(params.groupId);
                 const entry = await kv.get(params.key);
                 if (!entry)
-                    return { content: [{ type: 'text', text: 'Key not found.' }], details: {} };
-                const val = new TextDecoder().decode(entry.value);
-                return { content: [{ type: 'text', text: `--- KEY: ${params.key} (Rev: ${entry.revision}) ---\n${val}` }], details: { revision: entry.revision, value: val } };
+                    return { content: [{ type: 'text', text: 'Not found' }], details: {} };
+                return { content: [{ type: 'text', text: new TextDecoder().decode(entry.value) }], details: { revision: entry.revision } };
             }
             catch (err) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+                return { content: [{ type: 'text', text: err.message }], details: {} };
             }
         }
     }, { optional: true });
     api.registerTool({
         name: STRATEGY_BOARD_TOOLS.UPDATE_ITEM,
         label: 'Update Board Item',
-        description: 'Update or create an item on the whiteboard. Use this to persist group consensus, API specs, or task progress.',
+        description: 'Update or create consensus on the whiteboard (Markdown supported).',
         parameters: {
             type: 'object',
-            properties: {
-                groupId: { type: 'string', description: 'The Workspace Group ID' },
-                key: { type: 'string', description: 'The key to update' },
-                value: { type: 'string', description: 'The new content (Markdown supported)' }
-            },
+            properties: { groupId: { type: 'string' }, key: { type: 'string' }, value: { type: 'string' } },
             required: ['groupId', 'key', 'value']
         },
-        async execute(_id, params, ctx) {
-            const robot = instances.get(params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
-            if (!robot)
-                return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
-            try {
-                const kv = await robot.client.nats.getWorkspaceKV(params.groupId);
-                await kv.put(params.key, new TextEncoder().encode(params.value));
-                return { content: [{ type: 'text', text: `Successfully updated board item: ${params.key}` }], details: { key: params.key } };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
-            }
-        }
-    }, { optional: true });
-    api.registerTool({
-        name: 'pier_update_whiteboard',
-        label: 'Update Whiteboard',
-        description: 'Update the shared state on the workspace whiteboard using CAS (Compare-And-Swap). Provide expected_revision from read.',
-        parameters: {
-            type: 'object',
-            properties: {
-                groupId: { type: 'string' },
-                key: { type: 'string' },
-                value: { type: 'string' },
-                expected_revision: { type: 'number', description: 'The revision number from the last read (use 0 if key not found)' },
-                namespace: { type: 'string' }
-            },
-            required: ['groupId', 'key', 'value', 'expected_revision']
-        },
         async execute(_id, params, ctx) {
             const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
             if (!robot)
-                return { content: [{ type: 'text', text: 'Robot not found' }], details: {} };
+                return { content: [{ type: 'text', text: 'Error' }], details: {} };
             try {
                 const kv = await robot.client.nats.getWorkspaceKV(params.groupId);
-                try {
-                    // if expected_revision is 0 it means we expect the key does not exist yet (or we use create)
-                    if (params.expected_revision === 0) {
-                        try {
-                            await kv.create(params.key, new TextEncoder().encode(params.value));
-                        }
-                        catch (e) {
-                            if (e.message?.includes('wrong last sequence'))
-                                throw e; // Pass to conflict handler
-                            await kv.update(params.key, new TextEncoder().encode(params.value), 0); // fallback
-                        }
-                    }
-                    else {
-                        await kv.update(params.key, new TextEncoder().encode(params.value), params.expected_revision);
-                    }
-                    return { content: [{ type: 'text', text: `Whiteboard key '${params.key}' updated successfully.` }], details: {} };
-                }
-                catch (updateErr) {
-                    if (updateErr.message && (updateErr.message.includes('wrong last sequence') || updateErr.code === '400' || updateErr.api_error?.err_code === 10071)) {
-                        return { content: [{ type: 'text', text: `ERROR: CAS Conflict - Another agent modified this key while you were working. Please use pier_read_whiteboard to get the latest revision and try again.` }], details: {} };
-                    }
-                    throw updateErr;
-                }
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
-            }
-        }
-    }, { optional: true });
-    api.registerTool({
-        name: 'pier_group_mention',
-        label: 'Mention in Workspace',
-        description: 'Send a message in the workspace group chat explicitly mentioning an agent to wake them up',
-        parameters: {
-            type: 'object',
-            properties: {
-                groupId: { type: 'string' },
-                mentions: { type: 'array', items: { type: 'string' }, description: 'Array of target Agent Node IDs' },
-                content: { type: 'string', description: 'Message content' },
-                namespace: { type: 'string' }
-            },
-            required: ['groupId', 'mentions', 'content']
-        },
-        async execute(_id, params, ctx) {
-            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
-            if (!robot)
-                return { content: [{ type: 'text', text: 'Robot not found' }], details: {} };
-            try {
-                const msgId = globalThis.crypto.randomUUID ? globalThis.crypto.randomUUID() : (Math.random().toString(36).substring(2));
-                const ns = params.namespace || 'default';
-                let payload = {
-                    version: 'psp-1.0',
-                    id: msgId,
-                    namespace: ns,
-                    timestamp: Date.now(),
-                    senderId: robot.accountId,
-                    groupId: params.groupId,
-                    content: params.content,
-                    mentions: params.mentions
-                };
-                if (robot.config.privateKey) {
-                    payload = await PierCrypto.signSwarmMessage(payload, robot.config.privateKey);
-                }
-                await robot.client.nats.publishGroupChat(params.groupId, payload, ns);
-                return { content: [{ type: 'text', text: `Message sent to workspace ${params.groupId} successfully.` }], details: {} };
+                await kv.put(params.key, new TextEncoder().encode(params.value));
+                return { content: [{ type: 'text', text: 'Board updated' }], details: {} };
             }
             catch (err) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+                return { content: [{ type: 'text', text: err.message }], details: {} };
             }
         }
     }, { optional: true });
     api.registerTool({
-        name: 'pier_search_workers',
-        label: 'Search Workers',
-        description: 'Find active agents on the Pier network. When \`capability\` is provided, uses fast Subject-based Discovery (PSP 1.0). Falls back to KV full-scan if omitted.',
-        parameters: {
-            type: 'object',
-            properties: {
-                capability: { type: 'string', description: '(Recommended) Filter by a specific capability e.g. "translation", "code-execution". Uses fast per-subject discovery when set.' }
-            }
-        },
-        async execute(_id, params, ctx) {
-            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
-            if (!robot)
-                return { content: [{ type: 'text', text: 'Error' }], details: {} };
-            // --- PSP 1.0 Subject-based Discovery (fast path, used when capability is specified) ---
-            if (params.capability) {
-                try {
-                    const nodes = await robot.client.nats.queryDiscovery(params.capability);
-                    return { content: [{ type: 'text', text: JSON.stringify(nodes, null, 2) }], details: {} };
-                }
-                catch (e) {
-                    // Fall through to KV scan
-                }
-            }
-            // --- KV Full-scan (fallback when no capability filter, or subject discovery fails) ---
-            try {
-                const kv = await robot.client.nats.getWorkspaceKV('active_nodes');
-                const activeNodes = [];
-                const iter = await kv.keys();
-                for await (const k of iter) {
-                    const entry = await kv.get(k);
-                    if (entry) {
-                        try {
-                            // S10: DoS protection
-                            if (entry.value.length > 1024 * 1024)
-                                continue;
-                            const nodeData = JSON.parse(new TextDecoder().decode(entry.value));
-                            if (Date.now() - nodeData.timestamp < 120000) {
-                                // --- Zero-Trust: Verify signed heartbeat (PSP 1.0 Hard-Block) ---
-                                if (nodeData.version === 'psp-1.0' && nodeData.signature && nodeData.publicKey) {
-                                    const isValid = PierCrypto.verifySwarmMessage(nodeData);
-                                    if (!isValid) {
-                                        console.warn(`[pier_search_workers] 🔴 Dropping node ${k}: invalid signature (spoofed identity).`);
-                                        continue;
-                                    }
-                                }
-                                activeNodes.push(nodeData);
-                            }
-                        }
-                        catch (e) { }
-                    }
-                }
-                return { content: [{ type: 'text', text: JSON.stringify(activeNodes.slice(0, 10), null, 2) }], details: {} };
-            }
-            catch (e) {
-                // Final fallback: central API
-                try {
-                    const resp = await fetch(`${robot.client.apiUrl}/nodes`);
-                    const nodes = await resp.json();
-                    const active = nodes.filter((n) => n.is_online).slice(0, 10);
-                    return { content: [{ type: 'text', text: JSON.stringify(active, null, 2) }], details: {} };
-                }
-                catch (fallbackErr) {
-                    return { content: [{ type: 'text', text: `All discovery methods failed: ${e.message}` }], details: {} };
-                }
-            }
-        }
-    }, { optional: true });
-    api.registerTool({
-        name: 'pier_invite_collaborator',
-        label: 'Invite to Workspace',
-        description: 'Send a targeted job request to a node to invite them.',
-        parameters: {
-            type: 'object',
-            properties: {
-                nodeId: { type: 'string' },
-                groupId: { type: 'string' },
-                roleDescription: { type: 'string' },
-                namespace: { type: 'string' }
-            },
-            required: ['nodeId', 'groupId', 'roleDescription']
-        },
+        name: 'pier_get_profile',
+        label: 'Pier Profile',
+        description: 'Get current Pier node stats.',
+        parameters: { type: 'object', properties: { accountId: { type: 'string' } } },
         async execute(_id, params, ctx) {
-            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            const robot = instances.get(params.accountId || ctx?.accountId || 'default') || instances.values().next().value;
             if (!robot)
                 return { content: [{ type: 'text', text: 'Error' }], details: {} };
             try {
-                let req = createRequestPayload({
-                    task: `INVITATION: Join my workspace ${params.groupId}.\nRole: ${params.roleDescription}\nPlease use 'pier_group_mention' tool to reply in group ${params.groupId}.\nYou can also use 'pier_read_whiteboard' with groupId=${params.groupId} to view the plan.`,
-                    targetNodeId: params.nodeId,
-                    namespace: params.namespace || 'default',
-                    senderId: robot.accountId,
-                    meta: { sender: robot.accountId, workspace: params.groupId }
-                });
-                if (robot.config.privateKey) {
-                    req = await PierCrypto.signSwarmMessage(req, robot.config.privateKey);
-                }
-                await robot.js.publish(`jobs.node.${params.nodeId}`, new TextEncoder().encode(JSON.stringify(req)));
-                return { content: [{ type: 'text', text: `Invitation sent to ${params.nodeId}` }], details: {} };
+                const profile = await robot.client.getUserProfile(robot.config.secretKey);
+                return { content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }], details: {} };
             }
-            catch (e) {
-                return { content: [{ type: 'text', text: e.message }], details: {} };
+            catch (err) {
+                return { content: [{ type: 'text', text: err.message }], details: {} };
             }
         }
     }, { optional: true });
-    // Status Command
-    api.registerCommand({
-        name: 'pier',
-        description: 'Show Pier status',
-        handler: () => {
-            const lines = ['**Pier Connector Status**'];
-            instances.forEach((r, id) => {
-                lines.push(`\n**Account: ${id}**\n• Status: ${r.connectionStatus}\n• Jobs: ${r.stats.received}/${r.stats.completed}/${r.stats.failed}`);
-            });
-            return { text: lines.join('\n') };
-        }
-    });
     registerCli(api, globalStats);
     logger.info('[pier-connector] Plugin registered');
 };