@nekzus/liop 1.2.0-alpha.9 → 1.2.0

package/dist/server/index.js

@@ -1,3 +1,4 @@
+import { Buffer } from "node:buffer";
 import crypto from "node:crypto";
 import { createRequire } from "node:module";
 import path from "node:path";
@@ -8,8 +9,17 @@ import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { MeshNode } from "../mesh/node.js";
 import { LiopRpcServer } from "../rpc/server.js";
-import { PII_PATTERNS, PiiScanner } from "./pii.js";
-export { PII_PATTERNS, PiiScanner };
+import { log } from "../utils/logger.js";
+import { PII_PATTERNS, PII_PRESETS, PiiScanner } from "./pii.js";
+export { PII_PATTERNS, PII_PRESETS, PiiScanner };
+/**
+ * When enabled, `payload` tools that are not LIOP v1 envelopes are passed through to the
+ * registered handler unchanged (no worker extraction). Default off for strict protocol tests.
+ */
+function respectPlainToolPayload() {
+    const v = process.env.LIOP_RESPECT_PLAIN_TOOL_PAYLOAD?.toLowerCase().trim();
+    return v === "1" || v === "true" || v === "yes";
+}
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export class LiopServer {
     serverInfo;
@@ -28,16 +38,179 @@ export class LiopServer {
     workerPool;
     meshNode = null;
     rpcServer = null;
+    boundPort = null;
     sessions = new Map();
-    static LIOP_LOGIC_REGEX = /\s*LIOP_MAGIC:0x00FF\s*\n?\s*MANIFEST:(?<manifest>\{[\s\S]*?\})\s*\n?\s*---BEGIN_LOGIC---\n?(?<logic>[\s\S]*?)\n?---END_LOGIC---/m;
+    // Compact envelope: @LIOP{target,name}\n<code>\n@END
+    static LIOP_COMPACT_REGEX = /@LIOP\{(?<target>[^,}]+)(?:,(?<name>[^}]*))?\}\n(?<logic>[\s\S]*?)\n@END/m;
     extractLogic(payload) {
-        const match = payload.match(LiopServer.LIOP_LOGIC_REGEX);
-        return match?.groups?.logic ? match.groups.logic.trim() : null;
+        const compact = payload.match(LiopServer.LIOP_COMPACT_REGEX);
+        return compact?.groups?.logic ? compact.groups.logic.trim() : null;
+    }
+    parseUnknownJson(input) {
+        if (typeof input !== "string")
+            return input;
+        const trimmed = input.trim();
+        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+            (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch {
+                return input;
+            }
+        }
+        return input;
+    }
+    runPreflightPolicy(_toolName, logic, policy) {
+        if (!policy)
+            return null;
+        const compact = logic.replace(/\s+/g, " ");
+        if (policy.enforceAggregationFirst) {
+            const rowExtractionPatterns = [
+                /return\s+env\.records\b/i,
+                /return\s*\{[\s\S]*\b(accounts|patients|rows|records)\s*:\s*env\.records/i,
+            ];
+            if (rowExtractionPatterns.some((p) => p.test(compact))) {
+                return "Preflight policy rejected: potential row-level export pattern detected.";
+            }
+        }
+        if (policy.preflightDenyPatterns?.some((p) => p.test(compact))) {
+            return "Preflight policy rejected: custom deny pattern matched.";
+        }
+        return null;
+    }
+    validateOutputPolicy(toolName, output, policy) {
+        if (!policy)
+            return null;
+        const parsed = this.parseUnknownJson(output);
+        if (policy.outputSchema) {
+            const schemaResult = policy.outputSchema.safeParse(parsed);
+            if (!schemaResult.success) {
+                // Include a truncated preview of the rejected value so the LLM can self-correct
+                const preview = typeof parsed === "string"
+                    ? parsed.slice(0, 200)
+                    : JSON.stringify(parsed).slice(0, 200);
+                return `[LIOP] Output schema violation for ${toolName}: ${schemaResult.error.issues
+                    .map((i) => `${i.path.join(".") || "<root>"} ${i.message}`)
+                    .join("; ")}. Rejected value: ${preview}. HINT: Use 'env.records' to access the dataset inside your logic.`;
+            }
+        }
+        if (policy.enforceAggregationFirst &&
+            this.violatesAggregationFirstPolicy(this.unwrapForAggregationPolicyScan(parsed), policy.enforceAggregationFirst)) {
+            return "Aggregation-First Policy Violation: row-level export blocked. HINT: Use .reduce() to produce a flat {key:value} object. Do NOT use .map() to create arrays of objects.";
+        }
+        return null;
+    }
+    /**
+     * Proxied tools stringify a full MCP CallToolResult (`{ content: [...] }`).
+     * Aggregation-first heuristics must scan the inner business JSON, not the MCP envelope
+     * (otherwise `content` looks like a tabular array of objects and everything blocks).
+     */
+    unwrapForAggregationPolicyScan(input) {
+        if (typeof input === "string") {
+            const trimmed = input.trim();
+            if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+                (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+                try {
+                    return this.unwrapForAggregationPolicyScan(JSON.parse(trimmed));
+                }
+                catch {
+                    return input;
+                }
+            }
+            return input;
+        }
+        if (!input || typeof input !== "object") {
+            return input;
+        }
+        const rec = input;
+        if (!Array.isArray(rec.content) || rec.content.length === 0) {
+            return input;
+        }
+        const texts = [];
+        for (const part of rec.content) {
+            if (part && typeof part === "object" && "text" in part) {
+                const t = part.text;
+                if (typeof t === "string") {
+                    texts.push(t);
+                }
+            }
+        }
+        if (texts.length === 0) {
+            return input;
+        }
+        const joined = texts.length === 1 ? texts[0] : texts.join("\n");
+        return this.unwrapForAggregationPolicyScan(joined);
+    }
+    violatesAggregationFirstPolicy(input, policyObj) {
+        if (typeof input === "string") {
+            const trimmed = input.trim();
+            if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+                (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+                try {
+                    return this.violatesAggregationFirstPolicy(JSON.parse(trimmed), policyObj);
+                }
+                catch {
+                    return false;
+                }
+            }
+            return false;
+        }
+        if (Array.isArray(input)) {
+            const maxRows = typeof policyObj === "object" &&
+                typeof policyObj.maxOutputRows === "number"
+                ? policyObj.maxOutputRows
+                : 10;
+            const allowPrimitives = typeof policyObj === "object" &&
+                typeof policyObj.allowPrimitiveArrays === "boolean"
+                ? policyObj.allowPrimitiveArrays
+                : true;
+            if (input.length > 0 &&
+                input.every((item) => typeof item === "object" && item !== null)) {
+                // Treat tabular row export as non-aggregated leakage risk if above threshold.
+                if (input.length > maxRows) {
+                    return true;
+                }
+                return input.some((item) => this.violatesAggregationFirstPolicy(item, policyObj));
+            }
+            if (input.length > 0 &&
+                input.every((item) => typeof item !== "object" || item === null)) {
+                if (!allowPrimitives)
+                    return true;
+                return false;
+            }
+            return input.some((item) => this.violatesAggregationFirstPolicy(item, policyObj));
+        }
+        if (input && typeof input === "object") {
+            return Object.values(input).some((value) => this.violatesAggregationFirstPolicy(value, policyObj));
+        }
+        return false;
     }
     constructor(serverInfo, config) {
         this.serverInfo = serverInfo;
         this.config = config;
-        this.piiScanner = new PiiScanner(this.config?.security?.piiPatterns || [], this.config?.security?.forbiddenKeys || []);
+        this.piiScanner = new PiiScanner(this.config?.security?.piiPatterns ?? PII_PRESETS.GLOBAL_STRICT, this.config?.security?.forbiddenKeys ?? [
+            "id",
+            "name",
+            "fullName",
+            "firstName",
+            "lastName",
+            "address",
+            "street",
+            "city",
+            "postalCode",
+            "zipCode",
+            "phone",
+            "email",
+            "ssn",
+            "accountHolder",
+            "accountNumber",
+            "account_number",
+            "password",
+            "token",
+            "secret",
+            "privateKey",
+        ]);
         // Initialize Zero-Blocking Worker Pool for Heavy Cryptography & Sandboxing
         const isTS = import.meta.url.endsWith(".ts");
         const workerExt = isTS ? ".ts" : ".js";
@@ -67,6 +240,86 @@ export class LiopServer {
             taskQueue: new FixedQueue(),
             execArgv,
         });
+        // [Token Economy] Auto-register LIOP protocol spec as a single Resource.
+        // This centralizes the envelope documentation that was previously
+        // duplicated in every tool description, reducing token overhead.
+        this.resource("LIOP Envelope Specification", "liop://protocol/envelope-spec", "Complete Logic-on-Origin envelope format, execution rules, and security constraints", "text/plain", () => Promise.resolve(this.buildEnvelopeSpec()));
+    }
+    /**
+     * Builds the centralized LIOP envelope specification document.
+     * Served as a single Resource (liop://protocol/envelope-spec) instead
+     * of being duplicated across every tool description.
+     */
+    buildEnvelopeSpec() {
+        const lines = [
+            "LIOP v1 Envelope Specification",
+            "================================",
+            "",
+            "FORMAT:",
+            "",
+            "Compact Envelope:",
+            "  @LIOP{wasi_v1,TaskName}",
+            "  <JavaScript code>",
+            "  @END",
+            "",
+            "RUNTIME ENVIRONMENT:",
+            "- env.records: Array of data objects from the origin",
+            "- Must use 'return' to output results",
+            "- Zero-Trust WASI Sandbox (Node.js Worker Pool)",
+            "- Return aggregated objects, NOT raw row-level arrays",
+            "",
+            "SECURITY CONSTRAINTS:",
+            "- PII Egress Shield blocks raw identifiers in output",
+            "- Aggregation-First policy: prefer counts, averages, summaries",
+            "- AST Guardian: static analysis before execution",
+        ];
+        if (this.config?.security?.forbiddenKeys?.length) {
+            lines.push(`- Restricted fields: ${this.config.security.forbiddenKeys.join(", ")}`);
+        }
+        lines.push("", "OPTIONAL PARAMETERS:", "- __liop_bypass_ast_cache: boolean (force AST re-evaluation)");
+        return lines.join("\n");
+    }
+    /**
+     * Extracts a compact, human-readable field summary from a JSON Schema.
+     *
+     * Walks the schema structure to find actual data property names and types,
+     * rather than returning top-level schema metadata keys (type, items, etc.).
+     *
+     * Example output for a banking schema:
+     *   "Array of {id(string), accountHolder(string), balance(number), transactions(array of {date(string), amount(number)})}"
+     */
+    extractSchemaFieldSummary(schema, depth = 0) {
+        // Prevent excessive recursion in deeply nested schemas
+        if (depth > 3)
+            return "{...}";
+        const schemaType = schema.type;
+        const properties = schema.properties;
+        const items = schema.items;
+        // Object with properties → list field names with their types
+        if (properties) {
+            const fields = Object.entries(properties).map(([key, prop]) => {
+                const propType = prop.type;
+                if (propType === "array" && prop.items) {
+                    const nested = this.extractSchemaFieldSummary(prop.items, depth + 1);
+                    return `${key}(array of ${nested})`;
+                }
+                if (propType === "object" && prop.properties) {
+                    const nested = this.extractSchemaFieldSummary(prop, depth + 1);
+                    return `${key}(${nested})`;
+                }
+                return `${key}(${propType || "unknown"})`;
+            });
+            return `{${fields.join(", ")}}`;
+        }
+        // Array type → describe the items structure
+        if (schemaType === "array" && items) {
+            const itemsSummary = this.extractSchemaFieldSummary(items, depth + 1);
+            return `Array of ${itemsSummary}`;
+        }
+        // Simple type or unknown structure → fallback to key listing
+        if (schemaType)
+            return schemaType;
+        return Object.keys(schema).join(", ");
     }
     /**
      * Convenience alias for connectToMesh(), matching official documentation.
@@ -77,7 +330,7 @@ export class LiopServer {
     /**
      * Register a new Tool
      */
-    tool(name, description, shape, handler) {
+    tool(name, description, shape, handler, policy) {
         if (this.tools.has(name)) {
             throw new Error(`Tool already registered: ${name}`);
         }
@@ -88,14 +341,21 @@ export class LiopServer {
         // LIOP Zero-Shot Autonomy Middleware: Detect Logic-on-Origin tools
         if (shape.payload && shape.payload instanceof z.ZodString) {
             const blockedKeys = this.config?.security?.forbiddenKeys || [];
-            finalDescription += `\n\n[LIOP-PROTO-V1: LOGIC-ON-ORIGIN SPECIFICATION]\nCRITICAL: This tool requires a strictly formatted Logic-on-Origin payload. Failure to wrap JavaScript code within the LIOP envelope will result in a MalformedPayloadError.\n\nREQUIRED FORMAT:\nLIOP_MAGIC:0x00FF\nMANIFEST:{"target":"wasi_v1","name":"[ModuleName]","integrity_checks":true}\n---BEGIN_LOGIC---\n// Pure JavaScript logic. Access data via 'env.records'.\n// You MUST use 'return' to output results.\n---END_LOGIC---\n\nExecution Environment: Zero-Trust WASI Sandbox (Node.js Worker Pool).`;
+            // [Token Economy] Centralized description: reference the protocol spec
+            // Resource instead of duplicating the full envelope format per tool.
+            // Same information, delivered once via liop://protocol/envelope-spec.
+            finalDescription +=
+                "\n\nPayload: LIOP v1 envelope (WASI sandbox)." +
+                    " Format: @LIOP{wasi_v1,TaskName}\\n<JS code>\\n@END" +
+                    " | Access data: env.records. Return aggregated object." +
+                    " | Full spec: resource liop://protocol/envelope-spec";
             if (blockedKeys.length > 0) {
-                finalDescription += `\n// SECURITY RESTRICTION: Do NOT include any of the following fields: ${blockedKeys.join(", ")}`;
+                finalDescription += `\nRestricted fields: ${blockedKeys.join(", ")}.`;
             }
             if (this.activeSchema) {
-                finalDescription += `\n\nSTRICT SCHEMA ADHERENCE:\nThe 'env.records' array contains objects with: ${JSON.stringify(this.activeSchema)}`;
+                const schemaDigest = this.extractSchemaFieldSummary(this.activeSchema);
+                finalDescription += `\nData structure: ${schemaDigest}. Full schema: resource liop://schema/global`;
             }
-            finalDescription += `\n\nOptional: You can include an "__liop_bypass_ast_cache" boolean parameter set to true to force AST re-evaluation.`;
             finalHandler = async (args, _extra) => {
                 const clientId = "global_connection"; // Simplify for now, treating the instance as one connection
                 const now = Date.now();
@@ -131,10 +391,20 @@ export class LiopServer {
                     if (logic) {
                         args.payload = logic;
                         // DELEGATE TO WORKER POOL: Parallel PQC & Sandboxing
-                        return await this.executeInWorkerPool(args, logic);
+                        const preflightReason = this.runPreflightPolicy(name, logic, policy);
+                        if (preflightReason) {
+                            return {
+                                content: [{ type: "text", text: preflightReason }],
+                                isError: true,
+                            };
+                        }
+                        return await this.executeInWorkerPool(args, logic, name);
                     }
                 }
                 if (!logic) {
+                    if (respectPlainToolPayload()) {
+                        return await handler(args, _extra);
+                    }
                     stats.failures++;
                     stats.lastAttempt = now;
                     this.connectionStats.set(clientId, stats);
@@ -142,7 +412,7 @@ export class LiopServer {
                         content: [
                             {
                                 type: "text",
-                                text: 'Error: Malformed payload. Missing LIOP_MAGIC, MANIFEST, or boundaries.\nYou MUST wrap your logic exactly like this:\n\nLIOP_MAGIC:0x00FF\nMANIFEST:{"target":"wasi_v1","name":"DynamicAudit","integrity_checks":true}\n---BEGIN_LOGIC---\n// Your JS code here\n---END_LOGIC---',
+                                text: "Error: Malformed payload. Missing @LIOP boundary.\\nYou MUST wrap your logic exactly like this:\\n\\n@LIOP{wasi_v1,DynamicAudit}\\n// Your JS code here\\n@END",
                             },
                         ],
                         isError: true,
@@ -155,7 +425,17 @@ export class LiopServer {
                     // Extract pure logic and deliver it to the developer's function
                     args.payload = logic;
                     // DELEGATE TO WORKER POOL: Parallel PQC & Sandboxing (Includes PII Shield)
-                    const result = await this.executeInWorkerPool(args, logic);
+                    const preflightReason = this.runPreflightPolicy(name, logic, policy);
+                    if (preflightReason) {
+                        stats.failures++;
+                        stats.lastAttempt = now;
+                        this.connectionStats.set(clientId, stats);
+                        return {
+                            content: [{ type: "text", text: preflightReason }],
+                            isError: true,
+                        };
+                    }
+                    const result = await this.executeInWorkerPool(args, logic, name);
                     if (!result.isError) {
                         this.connectionStats.set(clientId, {
                             failures: 0,
@@ -196,11 +476,12 @@ export class LiopServer {
             tool: { name, description: finalDescription, inputSchema },
             handler: finalHandler,
             schema,
+            policy,
         });
         // [LIOP-ALPHA] Auto-announce capability to the Mesh P2P DHT if node is active
         if (this.meshNode) {
             this.meshNode.announceCapability(name).catch((err) => {
-                console.error(`[LIOP-Mesh] Failed to auto-announce tool ${name}: ${err.message}`);
+                log.info(`[LIOP-Mesh] Failed to auto-announce tool ${name}: ${err.message}`);
             });
         }
     }
@@ -234,13 +515,11 @@ Your objective is to perform secure Logic-on-Origin injections. You must process
 INDUSTRIAL CONSTRAINTS & PROTOCOL RULES:
 1. DATA PRIVACY: NEVER attempt to export Personally Identifiable Information (PII). The LIOP Egress Shield will block any response containing raw IDs, names, or addresses.
 2. AGGREGATION FIRST: Always prefer returning counts, averages, or anonymized summaries.
-3. PAYLOAD ENCAPSULATION: Your JavaScript payloads MUST strictly adhere to the LIOPv1 Envelope. DO NOT include markdown backticks or leading text inside the 'payload' argument.
+3. PAYLOAD ENCAPSULATION: Your JavaScript payloads MUST strictly adhere to the Compact Envelope. DO NOT include markdown backticks or leading text inside the 'payload' argument.
    Structure:
-   LIOP_MAGIC:0x00FF
-   MANIFEST:{"target":"wasi_v1","name":"AnalysisTask","integrity_checks":true}
-   ---BEGIN_LOGIC---
+   @LIOP{wasi_v1,AnalysisTask}
    // Your JS Code Here
-   ---END_LOGIC---
+   @END
 4. RUNTIME SCOPE: The execution environment provides a global 'env' object. Use 'env.records' to access the target dataset.
 5. LOCALIZATION: Format all JSON response keys in the language used by the user in their query (e.g., use Spanish keys if the query is in Spanish).
 6. SCHEMA RIGIDITY: Only use fields defined in the 'Data Dictionary'. Usage of non-existent fields will trigger a sandbox runtime exception.${this.activeSchema
@@ -268,13 +547,15 @@ Protocol Adherence is mandatory for successful execution.`,
      */
     dataDictionary(schema, name = "Global Medical Data Dictionary", uri = "liop://schema/global", description = "Exposes the internal database schema for Zero-Shot Autonomy planning") {
         this.activeSchema = schema;
-        // Retroactively update tool descriptions for already registered tools
+        // [Token Economy] Retroactively update tool descriptions with schema field references.
+        // Extracts actual data property names from the JSON Schema structure.
+        const schemaDigest = this.extractSchemaFieldSummary(schema);
         for (const [toolName, entry] of this.tools.entries()) {
             if (entry.schema.shape.payload &&
                 entry.schema.shape.payload instanceof z.ZodString &&
                 entry.tool.description &&
-                !entry.tool.description.includes("STRICT SCHEMA ADHERENCE")) {
-                entry.tool.description += `\n\nSTRICT SCHEMA ADHERENCE:\nThe 'env.records' array contains objects with the EXACT following structure. ONLY use these fields. Do NOT guess or use fallbacks (e.g. do not use 'gender' if not listed below):\n${JSON.stringify(schema, null, 2)}`;
+                !entry.tool.description.includes("Data structure:")) {
+                entry.tool.description += `\nData structure: ${schemaDigest}. Full schema: resource ${uri}`;
                 this.tools.set(toolName, entry);
             }
         }
@@ -285,7 +566,7 @@ Protocol Adherence is mandatory for successful execution.`,
      */
     clearAstCache() {
         this.logicCache.clear();
-        console.error("[LIOP-SDK] AST Security Cache cleared by Admin.");
+        log.info("[LIOP-SDK] AST Security Cache cleared by Admin.");
     }
     /**
      * Emulates calling a tool (used locally or via LIOPMcpBridge)
@@ -310,8 +591,15 @@ Protocol Adherence is mandatory for successful execution.`,
                     .payload;
                 const logic = this.extractLogic(payload);
                 if (logic) {
+                    const preflightReason = this.runPreflightPolicy(request.name, logic, entry.policy);
+                    if (preflightReason) {
+                        return {
+                            content: [{ type: "text", text: preflightReason }],
+                            isError: true,
+                        };
+                    }
                     parsedArgs.payload = logic;
-                    return await this.executeInWorkerPool(parsedArgs, logic);
+                    return await this.executeInWorkerPool(parsedArgs, logic, request.name);
                 }
             }
             const result = await entry.handler(parsedArgs, {});
@@ -401,12 +689,18 @@ Protocol Adherence is mandatory for successful execution.`,
     setSandboxData(records) {
         this.sandboxRecords = records;
     }
+    getBoundPort() {
+        return this.boundPort;
+    }
     /**
      * Connects to the libp2p Kademlia DHT and announces capabilities.
      * Boots the gRPC server for secure Logic-on-Origin.
      */
     async connectToMesh(options = {}) {
-        const port = options.port || 50051;
+        const envPort = process.env.LIOP_GRPC_PORT
+            ? Number.parseInt(process.env.LIOP_GRPC_PORT, 10)
+            : undefined;
+        const port = options.port ?? envPort ?? 50051;
         // 1. Initialize Mesh Node (Discovery)
         this.meshNode = new MeshNode(options.meshConfig);
         await this.meshNode.start();
@@ -436,16 +730,16 @@ Protocol Adherence is mandatory for successful execution.`,
         });
         // 3. Announce local tools to the DHT
         for (const tool of this.listTools()) {
-            await this.meshNode.announceCapability(tool.name).catch(console.error);
+            await this.meshNode.announceCapability(tool.name).catch(log.info);
         }
         // 4. Announce manifest availability
-        await this.meshNode.announceManifest().catch(console.error);
+        await this.meshNode.announceManifest().catch(log.info);
         // 5. Initialize gRPC Server (Execution)
         this.rpcServer = new LiopRpcServer();
         this.rpcServer.addService({
             negotiateIntent: (call, callback) => {
                 const request = call.request;
-                console.error(`[LIOP-RPC] Negotiating intent for capability: ${request.capability_hash}`);
+                log.info(`[LIOP-RPC] Negotiating intent for capability: ${request.capability_hash}`);
                 // Standard dynamic import to avoid potential circularity
                 import("../rpc/crypto/kyber.js").then(async ({ Kyber768Wrapper }) => {
                     const { publicKey, secretKey } = await Kyber768Wrapper.generateKeyPair();
@@ -464,7 +758,7 @@ Protocol Adherence is mandatory for successful execution.`,
             },
             executeLogic: async (call) => {
                 const request = call.request;
-                console.error(`[LIOP-RPC] Executing Logic-on-Origin for session: ${request.session_token}`);
+                log.info(`[LIOP-RPC] Executing Logic-on-Origin for session: ${request.session_token}`);
                 const session = this.sessions.get(request.session_token);
                 if (!session) {
                     call.emit("error", {
@@ -485,13 +779,16 @@ Protocol Adherence is mandatory for successful execution.`,
                         sessionToken: request.session_token,
                         isEncrypted: true,
                     });
-                    let finalOutput = workerResponse.output;
-                    // [PROTOCOL TRANSFORMER] Support for Proxied Tool Calls
-                    // If the execution resulted in a special proxy command, handle it
+                    let finalOutput;
                     try {
+                        finalOutput =
+                            typeof workerResponse.output === "string"
+                                ? workerResponse.output
+                                : JSON.stringify(workerResponse.output);
+                        // [PROTOCOL TRANSFORMER] Support for Proxied Tool Calls
                         const decoded = JSON.parse(finalOutput);
                         if (decoded.__liop_proxy_tool) {
-                            console.error(`[LIOP-RPC] Executing Proxied Tool: ${decoded.__liop_proxy_tool}`);
+                            log.info(`[LIOP-RPC] Executing Proxied Tool: ${decoded.__liop_proxy_tool}`);
                             const toolResult = await this.callTool({
                                 name: decoded.__liop_proxy_tool,
                                 arguments: decoded.__liop_proxy_args || {},
@@ -500,24 +797,26 @@ Protocol Adherence is mandatory for successful execution.`,
                         }
                     }
                     catch {
-                        // Not a proxy command, continue with raw output
+                        finalOutput = String(workerResponse.output);
                     }
                     const response = {
                         semantic_evidence: finalOutput,
                         cryptographic_proof: Buffer.from(workerResponse.image_id || "", "hex"),
-                        zk_receipt: crypto
-                            .createHash("sha256")
-                            .update(finalOutput)
-                            .digest(), // Deterministic Beta Seal
+                        zk_receipt: workerResponse.zk_receipt
+                            ? Buffer.from(workerResponse.zk_receipt, "base64")
+                            : Buffer.from(""),
                         is_error: false,
                     };
                     // Final PII check for gRPC egress
                     const violation = this.piiScanner.scan([
                         { type: "text", text: finalOutput },
                     ]);
-                    if (violation) {
-                        console.error(`[LIOP-RPC] PII Leak blocked in gRPC stream: ${violation}`);
-                        response.semantic_evidence = `[LIOP] Egress Security Violation. Output blocked due to PII leakage (${violation}).`;
+                    const aggregationViolation = this.violatesAggregationFirstPolicy(this.unwrapForAggregationPolicyScan(finalOutput));
+                    if (violation || aggregationViolation) {
+                        const reason = violation ||
+                            "Aggregation-First Policy Violation: row-level export blocked. HINT: Use .reduce() to produce a flat {key:value} object. Do NOT use .map() to create arrays of objects.";
+                        log.info(`[LIOP-RPC] Secure egress blocked in gRPC stream: ${reason}`);
+                        response.semantic_evidence = `[LIOP] Egress Security Violation. Output blocked due to policy enforcement (${reason}).`;
                         response.is_error = true;
                     }
                     call.write(response, () => {
@@ -526,7 +825,7 @@ Protocol Adherence is mandatory for successful execution.`,
                 }
                 catch (error) {
                     const e = error;
-                    console.error(`[LIOP-RPC] Execution Error: ${e.message}`);
+                    log.error(`[LIOP-RPC] Execution Error: ${e.message}`);
                     // Send error response before closing, avoiding "stream closed without results"
                     const errorResponse = {
                         semantic_evidence: `Execution Error: ${e.message}`,
@@ -545,13 +844,13 @@ Protocol Adherence is mandatory for successful execution.`,
                 }
             },
         });
-        await this.rpcServer.listen(port);
-        console.error(`[LIOP-SDK] Node successfully announced to Mesh. PeerID: ${this.meshNode.getPeerId()}`);
+        this.boundPort = await this.rpcServer.listen(port);
+        log.info(`[LIOP-SDK] Node successfully announced to Mesh. PeerID: ${this.meshNode.getPeerId()}`);
     }
     /**
      * Internal worker execution with Egress Filtering logic.
      */
-    async executeInWorkerPool(_args, rawPayload) {
+    async executeInWorkerPool(_args, rawPayload, toolName) {
         try {
             // Transparent local execution without dynamic PQC
             const workerResponse = await this.workerPool.run({
@@ -577,15 +876,29 @@ Protocol Adherence is mandatory for successful execution.`,
                     text: textOutput,
                 },
             ];
+            const toolPolicy = toolName
+                ? this.tools.get(toolName)?.policy
+                : undefined;
+            const policyViolation = this.validateOutputPolicy(toolName || "unknown_tool", workerResponse.output, toolPolicy);
+            if (policyViolation) {
+                log.info(`[LIOP-SDK] Output policy blocked for ${toolName || "unknown_tool"}: ${policyViolation}`);
+                return {
+                    content: [{ type: "text", text: `[LIOP] ${policyViolation}` }],
+                    isError: true,
+                };
+            }
             // Professional PII Protection Guard
             const violation = this.piiScanner.scan(content);
-            if (violation) {
-                console.error(`[LIOP-SDK] PII Leak blocked in local execution: ${violation}`);
+            const aggregationViolation = this.violatesAggregationFirstPolicy(workerResponse.output);
+            if (violation || aggregationViolation) {
+                const reason = violation ||
+                    "Aggregation-First Policy Violation: row-level export blocked. HINT: Use .reduce() to produce a flat {key:value} object. Do NOT use .map() to create arrays of objects.";
+                log.info(`[LIOP-SDK] Secure egress blocked in local execution: ${reason}`);
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `[LIOP] Egress Security Violation. Output blocked due to PII leakage (${violation}).`,
+                            text: `[LIOP] Egress Security Violation. Output blocked due to policy enforcement (${reason}).`,
                         },
                     ],
                     isError: true,

package/dist/server/pii.d.ts

@@ -14,6 +14,18 @@ export declare const PII_PATTERNS: {
     CREDIT_CARD: PiiRuleDefinition;
     IP_ADDRESS: PiiRuleDefinition;
     PHONE: PiiRuleDefinition;
+    SSN: PiiRuleDefinition;
+    IBAN: PiiRuleDefinition;
+    PASSPORT_MRZ: PiiRuleDefinition;
+};
+/**
+ * Regional and Cultural Security Presets for Out-Of-The-Box compliance.
+ * Developers can override, merge, or omit these based on local laws.
+ */
+export declare const PII_PRESETS: {
+    GLOBAL_STRICT: PiiRuleDefinition[];
+    US_COMPLIANT: PiiRuleDefinition[];
+    EU_GDPR: PiiRuleDefinition[];
 };
 export declare class PiiScanner {
     private patterns;