@gholl-studio/pier-connector 0.3.27 → 0.6.2

package/openclaw.plugin.json

@@ -18,6 +18,21 @@
                 "default": "https://pier-connector.gholl.com/api/v1",
                 "description": "Pier API Endpoint (from Website)"
             },
+            "nodeId": {
+                "type": "string",
+                "default": "",
+                "description": "Pier Node ID (from Website)"
+            },
+            "secretKey": {
+                "type": "string",
+                "default": "",
+                "description": "Pier Secret Key (from Website)"
+            },
+            "privateKey": {
+                "type": "string",
+                "default": "",
+                "description": "Pier Private (Signing) Key (starts with 0x)"
+            },
 
             "natsUrl": {
                 "type": "string",
@@ -58,6 +73,18 @@
             "label": "Pier API URL",
             "placeholder": "https://pier-connector.gholl.com/api/v1"
         },
+        "nodeId": {
+            "label": "Node ID",
+            "placeholder": "node-xxxxxxxx"
+        },
+        "secretKey": {
+            "label": "Secret Key",
+            "placeholder": "sk-xxxxxxxx"
+        },
+        "privateKey": {
+            "label": "Private Key (0x...)",
+            "placeholder": "0x..."
+        },
 
         "natsUrl": {
             "label": "NATS WebSocket URL (Override)",

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.3.27",
+    "version": "0.6.2",
     "description": "OpenClaw plugin that connects to the Pier job marketplace. Automatically fetches, executes, and reports distributed tasks for rewards.",
     "type": "module",
     "main": "src/index.ts",
@@ -40,7 +40,7 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@gholl-studio/pier-sdk": "^1.1.0",
+        "@gholl-studio/pier-sdk": "file:../packages/pier-sdk",
         "@nats-io/jetstream": "^3.3.1",
         "@nats-io/transport-node": "^3.0.0",
         "ethers": "^6.16.0",

package/src/inbound.ts

@@ -87,7 +87,7 @@ export async function handleInbound(
         Surface: 'pier',
         OriginatingChannel: 'pier',
         OriginatingTo: `chat:${jobId}`,
-        WasMentioned: true,
+        WasMentioned: inbound.WasMentioned ?? true,
         CommandAuthorized: true,
         SystemPrompt: injectedPrompt,
         MessageId: inbound.messageId,

package/src/index.ts

@@ -6,7 +6,7 @@
 
 import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
 import type { ChannelPlugin, OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk';
-import { protocol } from '@gholl-studio/pier-sdk';
+import { protocol, PierCrypto, TaskRequestParams } from '@gholl-studio/pier-sdk';
 const { createRequestPayload } = protocol;
 import { DEFAULTS } from './config.js';
 import { PierRobot } from './robot.js';
@@ -27,7 +27,7 @@ function mergedCfgFrom(legacy: any, account: any): PierAccountConfig {
         pierApiUrl: merged.pierApiUrl || DEFAULTS.PIER_API_URL,
         nodeId: merged.nodeId || DEFAULTS.NODE_ID,
         secretKey: merged.secretKey || DEFAULTS.SECRET_KEY,
-        privateKey: merged.privateKey || process.env.PIER_PRIVATE_KEY || DEFAULTS.PRIVATE_KEY,
+        privateKey: merged.privateKey || DEFAULTS.PRIVATE_KEY,
         natsUrl: merged.natsUrl || DEFAULTS.NATS_URL,
         subject: merged.subject || DEFAULTS.SUBJECT,
         publishSubject: merged.publishSubject || DEFAULTS.PUBLISH_SUBJECT,
@@ -405,6 +405,256 @@ const register = (api: PierPluginApi) => {
         }
     }, { 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: 'pier_read_whiteboard',
+        label: 'Read Whiteboard',
+        description: 'Read the current shared state from the workspace whiteboard (NATS KV)',
+        parameters: {
+            type: 'object',
+            properties: {
+                groupId: { type: 'string', description: 'The Workspace Group ID' },
+                key: { type: 'string', description: 'The key to read' },
+                namespace: { type: 'string', description: 'Federation namespace' }
+            },
+            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: {} };
+            
+            try {
+                const kv = await robot.client.nats.getWorkspaceKV(params.groupId);
+                const entry = await kv.get(params.key);
+                if (!entry) return { content: [{ type: 'text', text: '[Whiteboard: Key Not Found. Use revision 0 to update.]' }], details: { revision: 0 } };
+                const valueStr = new TextDecoder().decode(entry.value);
+                const result = JSON.stringify({ revision: entry.revision, value: valueStr });
+                return { content: [{ type: 'text', text: `Data retrieved:\n${result}\n(Supply this revision to pier_update_whiteboard)` }], details: { revision: entry.revision } };
+            } 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: {} };
+                }
+            }
+        }
+    }, { 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']
+        },
+        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: {} };
+            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: {} }; }
+        }
+    }, { optional: true });
+
     // Status Command
     api.registerCommand({
         name: 'pier',

package/src/job-handler.ts

@@ -10,6 +10,12 @@ const { normalizeInboundPayload } = protocol;
  * Parse a raw NATS message into a structured job object.
  */
 export function parseJob(msg: any, logger?: any) {
+    // S10: DoS protection - check raw bytes before stringifying
+    if (msg.data && msg.data.length > 1024 * 1024) { // 1MB limit
+        if (logger) logger.error(`[pier-connector] Payload too large: ${msg.data.length} bytes. Dropped.`);
+        return { ok: false, error: 'Payload size exceeded' };
+    }
+
     let raw: string;
     try {
         raw = msg.string();

package/src/robot.ts

@@ -3,10 +3,11 @@
  * @description Implements the PierRobot class, managing NATS connectivity, heartbeat, and job lifecycle.
  */
 
-import { PierClient, protocol } from '@gholl-studio/pier-sdk';
+import { PierClient, protocol, GroupMessagePayload, PierCrypto } from '@gholl-studio/pier-sdk';
 const { createRequestPayload, createResultPayload, createErrorPayload, normalizeInboundPayload } = protocol;
 import { safeRespond, truncate } from './job-handler.js';
 import { jetstream, jetstreamManager, AckPolicy, DeliverPolicy, type JetStreamClient, type JetStreamManager } from '@nats-io/jetstream';
+import { ethers } from 'ethers';
 import type { PierAccountConfig, PierPluginApi, InboundMessage } from './types.js';
 
 type NatsConnection = any; // Fallback for NatsConnection typing if not directly exported from jetstream
@@ -21,6 +22,11 @@ export class PierRobot {
     public jsm: JetStreamManager | null = null;
     public activeNodeJobs: Map<string, any> = new Map();
     public jobSubscriptions: Map<string, any> = new Map();
+    public groupRingBuffer: Map<string, GroupMessagePayload[]> = new Map();
+    // Anti-replay nonce cache: stores "senderId:nonce" -> expiry timestamp (5 min TTL)
+    private nonceCache: Map<string, number> = new Map();
+    private nonceKv: any = null;
+    private discoverySubscriptions: any[] = [];
     public isBusy: boolean = false;
     public connectionStatus: 'disconnected' | 'connecting' | 'connected' | 'error' = 'disconnected';
     public stats = { received: 0, completed: 0, failed: 0 };
@@ -67,6 +73,30 @@ export class PierRobot {
                 this.config.secretKey,
                 this.config.capabilities
             );
+
+            // Phase 2: Decentralized KV Keep-Alive (PSP 1.0 — signed heartbeat)
+            try {
+                const kv = await this.client.nats.getWorkspaceKV('active_nodes');
+                let heartbeatPayload: any = {
+                    version: 'psp-1.0',
+                    id: `hb_${this.config.nodeId}_${Date.now()}`,
+                    namespace: 'default',
+                    timestamp: Date.now(),
+                    senderId: this.accountId,
+                    // --- node fields ---
+                    nodeId: this.config.nodeId,
+                    accountId: this.accountId,
+                    capabilities: this.config.capabilities,
+                };
+                if (this.config.privateKey) {
+                    heartbeatPayload.publicKey = new ethers.Wallet(this.config.privateKey).address;
+                    heartbeatPayload = await PierCrypto.signSwarmMessage(heartbeatPayload, this.config.privateKey);
+                }
+                await kv.put(`node_${this.config.nodeId}`, new TextEncoder().encode(JSON.stringify(heartbeatPayload)));
+            } catch (kvErr: any) {
+                this.logger.debug(`[pier-connector][${this.accountId}] Decentralized KV Keep-Alive failed: ${kvErr.message}`);
+            }
+
             return data.nats_config || null;
         } catch (err: any) {
             this.logger.warn(`[pier-connector][${this.accountId}] Heartbeat failed: ${err.message}`);
@@ -111,6 +141,8 @@ export class PierRobot {
                 for await (const msg of iter) {
                     try {
                         const rawMsg = new TextDecoder().decode(msg.data);
+                        // S10: DoS protection
+                        if (msg.data.length > 1024 * 1024) { msg.ack(); continue; }
                         let msgPayload = JSON.parse(rawMsg);
 
                         if (msgPayload.id && processedMessages.has(msgPayload.id)) { msg.ack(); continue; }
@@ -155,16 +187,224 @@ export class PierRobot {
         }
     }
 
+    private async checkAndStoreNonce(senderId: string, nonce: string): Promise<boolean> {
+        const nonceCacheKey = `${senderId}:${nonce}`;
+        const now = Date.now();
+
+        // 1. Fast local cache check
+        if (this.nonceCache.has(nonceCacheKey)) {
+            return false;
+        }
+
+        // 2. Persistent KV check (if available)
+        if (this.nonceKv) {
+            try {
+                const existing = await this.nonceKv.get(nonceCacheKey);
+                if (existing) {
+                    this.nonceCache.set(nonceCacheKey, now + 5 * 60 * 1000);
+                    return false;
+                }
+                // Store in KV with TTL (the bucket has TTL, but we put it here)
+                await this.nonceKv.put(nonceCacheKey, new TextEncoder().encode(now.toString()));
+            } catch (e: any) {
+                this.logger.debug(`[pier-connector] Nonce KV check failed (falling back to memory): ${e.message}`);
+            }
+        }
+
+        // S13: Heap limit protection - prevent nonce collection from growing infinitely
+        const MAX_CACHE_ENTRIES = 100000;
+        if (this.nonceCache.size >= MAX_CACHE_ENTRIES) {
+             // Aggressive cleanup: drop everything older than now if still at limit
+             for (const [k, exp] of this.nonceCache) {
+                 if (exp < now) this.nonceCache.delete(k);
+             }
+             // If still over limit, reject new entry to protect memory
+             if (this.nonceCache.size >= MAX_CACHE_ENTRIES) {
+                 this.logger.warn(`[pier-connector] Nonce cache full (${this.nonceCache.size}). Memory protection triggered.`);
+                 return false;
+             }
+        }
+
+        // 3. Update local cache
+        this.nonceCache.set(nonceCacheKey, now + 5 * 60 * 1000);
+        
+        // Periodic local cleanup
+        if (this.nonceCache.size > 10000) {
+            for (const [k, exp] of this.nonceCache) {
+                if (exp < now) this.nonceCache.delete(k);
+            }
+        }
+        
+        return true;
+    }
+
+    /**
+     * S7: Decrement budget with CAS retry logic.
+     * Ensures atomic decrement even under high concurrency.
+     */
+    private async decrementBudgetWithRetry(groupId: string): Promise<{ success: boolean; budgetLeft: number }> {
+        const MAX_RETRIES = 5;
+        let attempt = 0;
+
+        while (attempt < MAX_RETRIES) {
+            try {
+                const kv = await this.client.nats.getWorkspaceKV(groupId);
+                const entry = await kv.get('budget');
+                if (!entry) return { success: true, budgetLeft: Infinity }; // No budget set, unlimited
+
+                let currentBudget = parseInt(new TextDecoder().decode(entry.value), 10);
+                if (isNaN(currentBudget)) return { success: true, budgetLeft: Infinity };
+
+                if (currentBudget <= 0) return { success: false, budgetLeft: 0 };
+
+                const nextBudget = currentBudget - 1;
+                try {
+                    await kv.update('budget', new TextEncoder().encode(nextBudget.toString()), entry.revision);
+                    return { success: true, budgetLeft: nextBudget };
+                } catch (casErr: any) {
+                    // CAS Failure: another node updated first. Retry.
+                    attempt++;
+                    this.logger.debug(`[pier-connector] Budget CAS conflict for ${groupId}, retry ${attempt}/${MAX_RETRIES}`);
+                    continue;
+                }
+            } catch (err: any) {
+                this.logger.error(`[pier-connector] Budget KV error: ${err.message}`);
+                return { success: false, budgetLeft: -1 };
+            }
+        }
+        return { success: false, budgetLeft: -1 }; // Retries exhausted
+    }
+
+    async handleGroupChat(subject: string, payload: GroupMessagePayload) {
+        if (!payload || !payload.id || !payload.groupId) return;
+        
+        // --- Zero-Trust Crypto Verification ---
+        if (payload.signature && payload.publicKey) {
+            const isValid = PierCrypto.verifySwarmMessage(payload as any);
+            if (!isValid) {
+                this.logger.warn(`[pier-connector][${this.accountId}] ⚠️ INVALID SIGNATURE from ${payload.senderId} (${payload.publicKey}). Message DROPPED.`);
+                return;
+            }
+        } else {
+            this.logger.warn(`[pier-connector][${this.accountId}] ⚠️ UNSIGNATURED MESSAGE from ${payload.senderId}. Accepting via Soft-Block fallback.`);
+        }
+
+        // Don't echo our own messages
+        if (payload.senderId === this.config.nodeId || payload.senderId === this.accountId) return;
+
+        // --- Anti-Replay: Nonce deduplication check (PSP 1.0) ---
+        if (payload.nonce) {
+            const isFresh = await this.checkAndStoreNonce(payload.senderId, payload.nonce);
+            if (!isFresh) {
+                this.logger.warn(`[pier-connector][${this.accountId}] ⛔ REPLAY ATTACK DETECTED: duplicate nonce from ${payload.senderId}. Dropped.`);
+                return;
+            }
+        }
+
+        const isMentioned = !!payload.mentions && (payload.mentions.includes(this.accountId) || payload.mentions.includes('all'));
+        
+        const buffer = this.groupRingBuffer.get(payload.groupId) || [];
+        buffer.push(payload);
+        if (buffer.length > 10) buffer.shift();
+        this.groupRingBuffer.set(payload.groupId, buffer);
+        
+        if (isMentioned) {
+             const backlog = buffer.slice(0, -1);
+             let injectedBody = payload.content;
+             if (backlog.length > 0) {
+                 const backlogText = backlog.map(m => `[${new Date(m.timestamp).toLocaleTimeString()}] ${m.senderId}: ${m.content}`).join('\n');
+                 injectedBody = `[System: You were just mentioned. Background context you overheard while silent:\n${backlogText}\nNow, please respond to the latest mention.]\n\n${payload.content}`;
+             }
+
+             // Setup FinOps Circuit Breaker Check (S7 Hardened)
+             try {
+                 const { success, budgetLeft } = await this.decrementBudgetWithRetry(payload.groupId);
+                 
+                 if (!success) {
+                     this.logger.error(`[pier-connector] Budget exhausted or update conflict for workspace ${payload.groupId}. Task BLOCKED.`);
+                     let sysPayload: any = {
+                         version: 'psp-1.0',
+                         id: `sys-${Date.now()}`,
+                         namespace: payload.namespace || 'default',
+                         groupId: payload.groupId,
+                         senderId: this.accountId,
+                         content: budgetLeft === 0 ? 'Critical Error: Workspace budget exhausted.' : 'Internal Error: Concurrent budget lock failure.',
+                         mentions: [],
+                         timestamp: Date.now()
+                     };
+                     if (this.config.privateKey) {
+                         sysPayload = await PierCrypto.signSwarmMessage(sysPayload, this.config.privateKey);
+                     }
+                     await this.client.nats.publishGroupChat(payload.groupId, sysPayload, sysPayload.namespace);
+                     return; // Hard Block / Fail-Close
+                 }
+
+                 if (budgetLeft <= 20 && budgetLeft !== Infinity) {
+                     injectedBody = `[System WARNING: FinOps Budget is extremely low (${budgetLeft} left). Please summarize your thoughts and conclude your work immediately.]\n\n` + injectedBody;
+                 }
+             } catch (err: any) {
+                 this.logger.warn(`Failed to check budget for workspace ${payload.groupId}: ${err.message}`);
+             }
+
+             this.logger.info(`[pier-connector][${this.accountId}] 🔔 Mentioned in group ${payload.groupId} by ${payload.senderId}`);
+             this.isBusy = true;
+             await this.onInbound({
+                 accountId: this.accountId,
+                 senderId: `pierWorkspace:${payload.senderId}`,
+                 body: injectedBody,
+                 jobId: payload.groupId,
+                 messageId: payload.id,
+                 WasMentioned: true
+             }, payload.groupId);
+             this.isBusy = false;
+        } else {
+             // Silently observe and update context without triggering LLM
+             this.logger.debug(`[pier-connector][${this.accountId}] 🤫 Observing group ${payload.groupId} (not mentioned, cached in RingBuffer)`);
+        }
+    }
+
     async handleMessage(msg: any) {
         const rawData = new TextDecoder().decode(msg.data);
         let payload: any;
         try {
+            // S10: DoS protection
+            if (msg.data.length > 1024 * 1024) { msg.ack(); return; }
             payload = JSON.parse(rawData);
         } catch (e) {
             msg.ack();
             return;
         }
 
+        // --- Zero-Trust Hard-Block for Task Payloads (PSP 1.0) ---
+        if (payload.version === 'psp-1.0' && (payload.type === 'task' || payload.type === 'task_request')) {
+            if (payload.signature && payload.publicKey) {
+                const isValid = PierCrypto.verifySwarmMessage(payload);
+                if (!isValid) {
+                    this.logger.warn(`[pier-connector][${this.accountId}] 🔴 HARD BLOCK: Invalid signature on task from ${payload.senderId}. Dropping.`);
+                    msg.ack(); // ACK to remove from queue but do NOT process
+                    return;
+                }
+            } else if (payload.signature !== undefined || payload.publicKey !== undefined) {
+                // Has one but not the other — tampered or malformed
+                this.logger.warn(`[pier-connector][${this.accountId}] 🔴 HARD BLOCK: Malformed Zero-Trust fields from ${payload.senderId}. Dropping.`);
+                msg.ack();
+                return;
+            } else {
+                // No signature — legacy / unsigned node. Soft-block: log and allow through.
+                this.logger.warn(`[pier-connector][${this.accountId}] ⚠️ Unsigned PSP task from ${payload.senderId}. Accepting via Soft-Block (legacy).`);
+            }
+        }
+
+        // --- Anti-Replay: Nonce deduplication for task payloads (PSP 1.0) ---
+        if (payload.nonce && payload.senderId) {
+            const isFresh = await this.checkAndStoreNonce(payload.senderId, payload.nonce);
+            if (!isFresh) {
+                this.logger.warn(`[pier-connector][${this.accountId}] ⛔ REPLAY ATTACK DETECTED: duplicate task nonce from ${payload.senderId}. Dropped.`);
+                msg.ack();
+                return;
+            }
+        }
+
         if (payload.type === 'wakeup') {
             const { jobId } = payload;
             if (jobId) {
@@ -296,6 +536,13 @@ export class PierRobot {
             this.jsm = await jetstreamManager(this.nc);
             this.connectionStatus = 'connected';
 
+            // Initialize Nonce Cache KV (S1 fix)
+            try {
+                this.nonceKv = await this.client.nats.getNonceCacheKV();
+            } catch (e: any) {
+                this.logger.warn(`[pier-connector] Failed to initialize Nonce KV: ${e.message}. Using memory only.`);
+            }
+
             const streamName = 'PIER_JOBS';
             const durableNameMarket = `pier_market_${this.config.nodeId.replace(/-/g, '_')}_${this.accountId}`;
             const durableNameDirect = `pier_node_${this.config.nodeId.replace(/-/g, '_')}_${this.accountId}`;
@@ -303,6 +550,27 @@ export class PierRobot {
             await this.setupMarketplaceConsumer(streamName, this.config.subject, durableNameMarket);
             await this.setupMarketplaceConsumer(streamName, `jobs.node.${this.config.nodeId}`, durableNameDirect);
 
+            // Subscribe to all multi-agent workspaces via NATS core
+            // Support PSP Federation namespace wildcards
+            this.client.nats.subscribe('psp.chat.>', (payload: any, msg: any) => {
+                this.handleGroupChat(msg.subject, payload);
+            });
+
+            // Register capability discovery responders (Subject-based Discovery, PSP 1.0)
+            if (this.config.capabilities && this.config.capabilities.length > 0) {
+                const discoveryInfo = {
+                    nodeId: this.config.nodeId,
+                    accountId: this.accountId,
+                    capabilities: this.config.capabilities,
+                    timestamp: Date.now(),
+                };
+                for (const cap of this.config.capabilities) {
+                    const sub = await this.client.nats.subscribeDiscovery(cap, discoveryInfo, this.config.privateKey);
+                    this.discoverySubscriptions.push(sub);
+                }
+                this.logger.info(`[pier-connector][${this.accountId}] 📟 Registered for discovery on ${this.config.capabilities.length} capabilities`);
+            }
+
             if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
             this.heartbeatTimer = setInterval(() => this.heartbeat(), 60000);
         } catch (err: any) {
@@ -317,6 +585,13 @@ export class PierRobot {
             clearInterval(this.heartbeatTimer);
             this.heartbeatTimer = null;
         }
+
+        // Cleanup discovery subscriptions
+        for (const sub of this.discoverySubscriptions) {
+            try { sub.unsubscribe(); } catch (e) {}
+        }
+        this.discoverySubscriptions = [];
+
         if (this.nc) {
             await this.client.drainNats();
             this.nc = null;

package/src/types.ts

@@ -32,8 +32,10 @@ export interface InboundMessage {
   senderId: string;
   body: string;
   jobId: string;
-  /** 每条 NATS 消息的唯一 ID（msgPayload.id），用于 SDK 去重，必须每条消息不同 */
-  messageId: string;
+  /** UUID for unique SDK deduplication across turns */
+  messageId?: string;
+  /** True if the agent was explicitly mentioned in the group chat payload */
+  WasMentioned?: boolean;
 }
 
 export type PierPluginApi = OpenClawPluginApi;