@gholl-studio/pier-connector 0.7.2 → 0.7.4

package/src/index.ts

@@ -100,8 +100,6 @@ const pierPlugin: ChannelPlugin<PierAccountConfig> = {
         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}`);
         }
     },
@@ -135,7 +133,6 @@ const pierPlugin: ChannelPlugin<PierAccountConfig> = {
             };
 
             if (isWorkspace) {
-                // Use SDK-aligned workspace protocol (includes signing if configured)
                 const ns = (ctx as any).metadata?.namespace || 'default';
                 let swarmPayload: any = {
                     ...payload,
@@ -149,7 +146,6 @@ const pierPlugin: ChannelPlugin<PierAccountConfig> = {
                 }
                 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)));
             }
@@ -189,9 +185,7 @@ const pierPlugin: ChannelPlugin<PierAccountConfig> = {
     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 as any, async (inbound, jobId) => {
-                // Pass the context containing channelRuntime
                 await handleInbound(ctx, inbound, jobId, robot, pierPlugin);
             });
             instances.set(ctx.accountId, robot);
@@ -207,13 +201,10 @@ const pierPlugin: ChannelPlugin<PierAccountConfig> = {
                     lastStartAt: (robot as any).lastStartAt 
                 } as any);
 
-                // 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<void>((resolve) => {
                     ctx.abortSignal.addEventListener('abort', () => {
                         resolve();
                     }, { once: true });
-                    
                     if (ctx.abortSignal.aborted) resolve();
                 });
                 
@@ -248,10 +239,9 @@ const register = (api: PierPluginApi) => {
     const logger = api.logger;
     const globalStats = { received: 0, completed: 0, failed: 0 };
 
-    // Register our new ChannelPlugin
     api.registerChannel({ plugin: pierPlugin as any });
 
-    // Tools and CLI registration
+    // --- Market Tools ---
     api.registerTool({
         name: 'pier_publish',
         label: 'Publish to Pier',
@@ -268,59 +258,59 @@ const register = (api: PierPluginApi) => {
             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.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    jobId: { type: 'string' },
-                    text: { type: 'string' },
-                    accountId: { type: 'string' }
-                },
-                required: ['jobId', 'text']
+    api.registerTool({
+        name: 'pier_chat',
+        label: 'Pier Chat',
+        description: 'Send a message in a specific job chat or workspace group.',
+        parameters: {
+            type: 'object',
+            properties: {
+                jobId: { type: 'string' },
+                text: { type: 'string' },
+                accountId: { type: 'string' }
             },
-            async execute(_id, params, ctx: any) {
-                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: 'Error: Robot not connected' }], details: {} };
-                }
+            required: ['jobId', 'text']
+        },
+        async execute(_id, params, ctx: any) {
+            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: '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;
+            try {
+                let metadata = robot.activeNodeJobs.get(params.jobId);
+                const jobId = metadata?.pierJobId || params.jobId;
+                const isWorkspace = metadata?.workspace === true || jobId.startsWith('job-');
 
-                    if (!robot.js) {
-                        return { content: [{ type: 'text', text: 'Error: JetStream not available' }], details: {} };
-                    }
+                if (!robot.js) return { content: [{ type: 'text', text: 'Error: JetStream not available' }], details: {} };
 
+                if (isWorkspace) {
                     const payload: any = {
+                        id: (globalThis.crypto as any).randomUUID ? (globalThis.crypto as any).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) {
+                        const signed = await PierCrypto.signSwarmMessage(payload, robot.config.privateKey);
+                        await robot.client.nats.publishGroupChat(jobId, signed);
+                    } else {
+                        await robot.client.nats.publishGroupChat(jobId, payload);
+                    }
+                } else {
+                    const payload = {
                         id: (globalThis.crypto as any).randomUUID ? (globalThis.crypto as any).randomUUID() : (Math.random().toString(36).substring(2)),
                         job_id: jobId,
                         sender_id: robot.config.nodeId,
@@ -331,429 +321,133 @@ const register = (api: PierPluginApi) => {
                         auth_token: robot.config.secretKey,
                         timestamp: Date.now()
                     };
-
-                    if (isWorkspace) {
-                        let swarmPayload: any = {
-                            ...payload,
-                            version: 'psp-1.0',
-                            groupId: jobId,
-                            senderId: robot.accountId,
-                        };
-                        if (robot.config.privateKey) {
-                            swarmPayload = await PierCrypto.signSwarmMessage(swarmPayload, robot.config.privateKey);
-                        }
-                        await robot.client.nats.publishGroupChat(jobId, swarmPayload);
-                    } else {
-                        const subject = `chat.${jobId}`;
-                        await robot.js.publish(subject, new TextEncoder().encode(JSON.stringify(payload)));
-                    }
-                    return { content: [{ type: 'text', text: 'Message sent' }], details: {} };
-                } catch (err: any) {
-                    return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+                    await robot.js.publish(`chat.${jobId}`, new TextEncoder().encode(JSON.stringify(payload)));
                 }
+                return { content: [{ type: 'text', text: 'Message sent' }], details: {} };
+            } catch (err: any) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
             }
-        },
-        { optional: true }
-    );
+        }
+    }, { optional: true });
 
-    // Helper to register marketplace action tools
-    const registerSystemActionTool = (name: string, label: string, description: string, action: string, extraParams: any, userRole = 'node') => {
+    // Helper for marketplace system actions
+    const regSystemAction = (name: string, action: string, extraParams: any = {}) => {
         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: any) {
-                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 as any).randomUUID ? (globalThis.crypto as any).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: {} };
-                } catch (err: any) {
-                    return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
-                }
+                    return { content: [{ type: 'text', text: 'Executed' }], details: {} };
+                } catch (e: any) { 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');
+    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 ---
+    // Standard names using STRATEGY_BOARD_TOOLS constant which already includes 'pier_' prefix
     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: any) {
-            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: any) {
-                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: any) {
-            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 as any).randomUUID ? (globalThis.crypto as any).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: any) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
-            }
-        }
-    }, { optional: true });
-
-    api.registerTool({
-        name: STRATEGY_BOARD_TOOLS.LIST_KEYS,
+        name: STRATEGY_BOARD_TOOLS.LIST_KEYS, // 'pier_list_board_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: any) {
-            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: {} };
+            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            if (!robot) 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 } };
-            } catch (err: any) {
-                return { content: [{ type: 'text', text: `Error or Board Empty: ${err.message}` }], details: {} };
-            }
+                return { content: [{ type: 'text', text: `Board Keys:\n${list.join('\n') || '[Empty]'}` }], details: {} };
+            } catch (err: any) { return { content: [{ type: 'text', text: err.message }], details: {} }; }
         }
     }, { optional: true });
 
     api.registerTool({
-        name: STRATEGY_BOARD_TOOLS.READ_ITEM,
+        name: STRATEGY_BOARD_TOOLS.READ_ITEM, // 'pier_read_board_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: any) {
-            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: {} };
+            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            if (!robot) 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 } };
-            } catch (err: any) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
-            }
+                if (!entry) return { content: [{ type: 'text', text: 'Not found' }], details: {} };
+                return { content: [{ type: 'text', text: new TextDecoder().decode(entry.value) }], details: { revision: entry.revision } };
+            } catch (err: any) { return { content: [{ type: 'text', text: err.message }], details: {} }; }
         }
     }, { optional: true });
 
     api.registerTool({
-        name: STRATEGY_BOARD_TOOLS.UPDATE_ITEM,
+        name: STRATEGY_BOARD_TOOLS.UPDATE_ITEM, // 'pier_update_board_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: any) {
-            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: any) {
-                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: any) {
-            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 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: any) {
-                            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: any) {
-                    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: any) {
-                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: any) {
-            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 as any).randomUUID ? (globalThis.crypto as any).randomUUID() : (Math.random().toString(36).substring(2));
-                const ns = params.namespace || 'default';
-                
-                let payload: any = {
-                    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: {} };
-            } catch (err: any) {
-                return { content: [{ type: 'text', text: `Error: ${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: any) {
             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: any) {
-                    // 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: any) {
-                // Final fallback: central API
-                try {
-                    const resp = await fetch(`${robot.client.apiUrl}/nodes`);
-                    const nodes = await resp.json();
-                    const active = nodes.filter((n: any) => n.is_online).slice(0, 10);
-                    return { content: [{ type: 'text', text: JSON.stringify(active, null, 2) }], details: {} };
-                } catch (fallbackErr: any) {
-                    return { content: [{ type: 'text', text: `All discovery methods failed: ${e.message}` }], details: {} };
-                }
-            }
+                const kv = await robot.client.nats.getWorkspaceKV(params.groupId);
+                await kv.put(params.key, new TextEncoder().encode(params.value));
+                return { content: [{ type: 'text', text: 'Board updated' }], details: {} };
+            } catch (err: any) { return { content: [{ type: 'text', text: err.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: any) {
-            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: any = 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 }
-                } as TaskRequestParams);
-                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: {} };
-            } catch(e: any) { return { content: [{ type: 'text', text: e.message }], details: {} }; }
+                const profile = await robot.client.getUserProfile(robot.config.secretKey);
+                return { content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }], details: {} };
+            } catch (err: any) { 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');
 };
@@ -764,4 +458,3 @@ export default definePluginEntry({
     description: 'Connects OpenClaw to the Pier job marketplace.',
     register
 });
-