@wowok/agent-mcp 2.6.9 → 2.7.1

package/dist/intent/types.d.ts

@@ -0,0 +1,33 @@
+import type { IndustryScenario } from "../evaluation/capability.js";
+import type { PersonaRole } from "../persona/types.js";
+export type IntentTargetType = "NewOrderEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent" | "ArbEvent";
+export interface IntentRecord {
+    id: string;
+    intent: string;
+    account?: string;
+    role?: PersonaRole;
+    industries: IndustryScenario[];
+    keywords: string[];
+    target_types: IntentTargetType[];
+    created_at: number;
+    updated_at: number;
+}
+export interface IntentEventHit {
+    event_type: string;
+    event_id: string;
+    related_objects: string[];
+    business_meaning: string;
+    score: number;
+    matched_industries: string[];
+    matched_keywords: string[];
+    event: Record<string, unknown>;
+}
+export interface IntentMatchResult {
+    intent_id: string;
+    intent: string;
+    hits: IntentEventHit[];
+    scanned: number;
+}
+export declare const INTENT_VERSION = 1;
+export declare const INTENT_MAX_PER_SCOPE = 50;
+export declare const ALL_INTENT_TARGET_TYPES: IntentTargetType[];

package/dist/intent/types.js

@@ -0,0 +1,10 @@
+export const INTENT_VERSION = 1;
+export const INTENT_MAX_PER_SCOPE = 50;
+export const ALL_INTENT_TARGET_TYPES = [
+    "NewOrderEvent",
+    "ProgressEvent",
+    "DemandPresentEvent",
+    "DemandFeedbackEvent",
+    "NewEntityEvent",
+    "ArbEvent",
+];

package/dist/knowledge/arbitration-risk.js

@@ -138,16 +138,6 @@ const R_AB_2_01 = {
         return null;
     },
 };
-const R_AB_2_02 = {
-    id: "R-AB-2-02",
-    category: "semantic",
-    trigger: "usage_guard set but dispute without passport — E_NEED_PASSPORT",
-    check: (ctx) => {
-        if (ctx.dispute && ctx.current_voting_guard_addresses !== undefined) {
-        }
-        return null;
-    },
-};
 const R_AB_2_03 = {
     id: "R-AB-2-03",
     category: "semantic",
@@ -382,7 +372,7 @@ const R_AB_5_02 = {
 };
 const ALL_RULES = [
     R_AB_1_01, R_AB_1_02, R_AB_1_03, R_AB_1_04,
-    R_AB_2_01, R_AB_2_02, R_AB_2_03,
+    R_AB_2_01, R_AB_2_03,
     R_AB_3_01, R_AB_3_02, R_AB_3_03,
     R_AB_4_01, R_AB_4_02, R_AB_4_03,
     R_AB_5_01, R_AB_5_02,

package/dist/knowledge/contact-templates.d.ts

@@ -0,0 +1,27 @@
+export type ContactTemplateParamType = "string";
+export interface ContactTemplateParam {
+    name: string;
+    type: ContactTemplateParamType;
+    description: string;
+    required: boolean;
+}
+export interface ContactTemplate {
+    id: string;
+    name: string;
+    description: string;
+    applicable_scenes: string[];
+    industry_tags: string[];
+    params: ContactTemplateParam[];
+    body: (params: Record<string, string>) => object;
+    notes?: string[];
+}
+export declare const CONTACT_TEMPLATES: ContactTemplate[];
+export declare const CONTACT_TEMPLATES_VERSION = "1.0.0";
+export declare function getContactTemplateById(id: string): ContactTemplate | undefined;
+export declare function fillTemplate(templateId: string, params: Record<string, string>): {
+    ok: true;
+    body: object;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/knowledge/contact-templates.js

@@ -0,0 +1,60 @@
+export const CONTACT_TEMPLATES = [
+    {
+        id: "T-C-01",
+        name: "Basic contact",
+        description: "Named contact with a permission reference and description. Bind to a Service via `um`.",
+        applicable_scenes: ["contact_basic"],
+        industry_tags: ["universal"],
+        params: [
+            { name: "name", type: "string", description: "Contact object name", required: true },
+            { name: "permission", type: "string", description: "Permission object name/address", required: true },
+            { name: "description", type: "string", description: "Contact description shown to customers", required: true },
+        ],
+        body: (p) => ({
+            object: { name: p.name, permission: p.permission, replaceExistName: true },
+            description: p.description,
+        }),
+        notes: ["Bind this contact to a Service via the service call's 'um' field"],
+    },
+    {
+        id: "T-C-02",
+        name: "Support contact with IM",
+        description: "Contact with an initial IM entry pointing at a support account (after-sales / pre-order).",
+        applicable_scenes: ["contact_support"],
+        industry_tags: ["retail", "rental", "education", "travel", "freelance", "subscription"],
+        params: [
+            { name: "name", type: "string", description: "Contact object name", required: true },
+            { name: "permission", type: "string", description: "Permission object name/address", required: true },
+            { name: "description", type: "string", description: "Contact description shown to customers", required: true },
+            { name: "support_account", type: "string", description: "Support account name or 0x address for IM", required: true },
+            { name: "im_description", type: "string", description: "IM entry description (e.g. 'Primary support representative')", required: true },
+        ],
+        body: (p) => ({
+            object: { name: p.name, permission: p.permission, replaceExistName: true },
+            description: p.description,
+            ims: {
+                op: "add",
+                im: [{ at: p.support_account, description: p.im_description }],
+            },
+        }),
+        notes: [
+            "ims.im[].at accepts an account name or a full 0x address",
+            "ims is an op discriminated union — {op:'add'|'set'|'remove'|'clear'}",
+        ],
+    },
+];
+export const CONTACT_TEMPLATES_VERSION = "1.0.0";
+export function getContactTemplateById(id) {
+    return CONTACT_TEMPLATES.find((t) => t.id === id);
+}
+export function fillTemplate(templateId, params) {
+    const tpl = getContactTemplateById(templateId);
+    if (!tpl)
+        return { ok: false, error: `Template ${templateId} not found` };
+    for (const p of tpl.params) {
+        if (p.required && !(p.name in params)) {
+            return { ok: false, error: `Missing required param: ${p.name}` };
+        }
+    }
+    return { ok: true, body: tpl.body(params) };
+}

package/dist/knowledge/examples-scanner.js

@@ -94,9 +94,27 @@ function extractJsonBlocks(mdPath) {
             }
             const raw = blockLines.join('\n');
             try {
-                const json = JSON.parse(raw);
-                if (json && typeof json === 'object' && 'operation_type' in json) {
-                    blocks.push({ lineStart: i + 1, raw, json: json });
+                const parsed = JSON.parse(raw);
+                let json = null;
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    const p = parsed;
+                    if (p.tool === 'onchain_operations' && p.data && typeof p.data === 'object'
+                        && !Array.isArray(p.data)) {
+                        const inner = p.data;
+                        if (typeof inner.operation_type === 'string') {
+                            json = {
+                                operation_type: inner.operation_type,
+                                data: inner.data,
+                                ...(inner.env !== undefined ? { env: inner.env } : {}),
+                            };
+                        }
+                    }
+                    else if (typeof p.operation_type === 'string') {
+                        json = p;
+                    }
+                }
+                if (json && typeof json.operation_type === 'string') {
+                    blocks.push({ lineStart: i + 1, raw, json });
                 }
             }
             catch {

package/dist/knowledge/fund-layer.js

@@ -897,17 +897,21 @@ export async function annotateTableItemMonetaryFields(item, parentTokenType, net
 export async function annotateEventMonetaryFields(event, network) {
     if (!event || typeof event !== "object")
         return;
-    if (event.type !== "NewOrderEvent")
+    const isNewOrder = event.type === "NewOrderEvent" ||
+        (typeof event.type === "string" && event.type.includes("::order::NewOrderEvent"));
+    if (!isNewOrder)
         return;
-    const raw = event.amount;
+    const pj = event.parsedJson_raw ?? {};
+    const raw = event.amount ?? pj.amount;
     if (raw === null || raw === undefined)
         return;
     if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "bigint")
         return;
     let tokenType;
-    if (typeof event.service === "string" && event.service) {
+    const service = event.service ?? pj.service;
+    if (typeof service === "string" && service) {
         try {
-            tokenType = (await resolveObjectTokenType(event.service, network))?.tokenType;
+            tokenType = (await resolveObjectTokenType(service, network))?.tokenType;
         }
         catch {
         }

package/dist/knowledge/industry-generalizer.js

@@ -1,50 +1,50 @@
 import { getIndustryProfile, listIndustries, registerIndustry, } from "./industry-registry.js";
 const TRAIT_INFERENCE_RULES = [
-    { keywords: ["logistics", "shipping", "delivery", "express", "shipment", "delivery", "shipping", "logistics", "ship"],
+    { keywords: ["logistics", "shipping", "delivery", "express", "shipment", "ship"],
         trait: "has_logistics", value: true, weight: 0.85 },
-    { keywords: ["digital", "online", "cloud", "online", "digital", "online", "cloud"],
+    { keywords: ["digital", "online", "cloud", "virtual"],
         trait: "has_logistics", value: false, weight: 0.7 },
-    { keywords: ["consulting", "communication", "requirement-confirmation", "revision-rounds", "consult", "communication", "negotiate"],
+    { keywords: ["consulting", "communication", "requirement-confirmation", "revision-rounds", "negotiate", "consult"],
         trait: "communication_heavy", value: true, weight: 0.8 },
     { keywords: ["standard-product", "in-stock", "one-click-order", "standard", "instant"],
         trait: "communication_heavy", value: false, weight: 0.7 },
-    { keywords: ["digital", "file", "code", "design-draft", "electronic", "online", "digital", "file", "online"],
+    { keywords: ["digital", "file", "code", "design-draft", "electronic", "online", "software", "source"],
         trait: "pure_digital", value: true, weight: 0.8 },
-    { keywords: ["physical", "hardware", "equipment", "physical", "hardware", "equipment"],
+    { keywords: ["physical", "hardware", "equipment"],
         trait: "pure_digital", value: false, weight: 0.75 },
-    { keywords: ["course", "semester", "long-cycle", "long-term", "project-based", "course", "semester", "long-term", "project"],
+    { keywords: ["course", "semester", "long-cycle", "long-term", "project-based", "project"],
         trait: "long_cycle", value: true, weight: 0.75 },
-    { keywords: ["instant", "in-stock", "same-day", "instant", "same-day", "immediate"],
+    { keywords: ["instant", "in-stock", "same-day", "immediate"],
         trait: "long_cycle", value: false, weight: 0.8 },
-    { keywords: ["rental", "rent", "deposit", "rental", "rent", "deposit", "lease"],
+    { keywords: ["rental", "rent", "deposit", "lease"],
         trait: "deposit_required", value: true, weight: 0.9 },
-    { keywords: ["purchase", "buyout", "purchase", "buy"],
+    { keywords: ["purchase", "buyout", "buy"],
         trait: "deposit_required", value: false, weight: 0.6 },
-    { keywords: ["multi-party", "segmented", "multi-stage", "multi-vendor", "itinerary", "multi-party", "segment", "multi-vendor"],
+    { keywords: ["multi-party", "segmented", "multi-stage", "multi-vendor", "itinerary", "segment"],
         trait: "multi_tier_allocation", value: true, weight: 0.75 },
-    { keywords: ["medical", "legal", "financial", "insurance", "pharmaceutical", "medical", "legal", "finance", "insurance", "pharma"],
+    { keywords: ["medical", "legal", "financial", "insurance", "pharmaceutical", "pharma"],
         trait: "regulatory_intensity", value: "high", weight: 0.9 },
-    { keywords: ["education", "food", "construction", "education", "food", "construction"],
+    { keywords: ["education", "food", "construction"],
         trait: "regulatory_intensity", value: "medium", weight: 0.7 },
-    { keywords: ["entertainment", "gaming", "digital", "entertainment", "game", "digital"],
+    { keywords: ["entertainment", "gaming", "digital", "game"],
         trait: "regulatory_intensity", value: "low", weight: 0.6 },
-    { keywords: ["custom", "high-value", "customized", "custom", "high-value", "bespoke"],
+    { keywords: ["custom", "high-value", "customized", "bespoke"],
         trait: "trust_sensitivity", value: "high", weight: 0.8 },
     { keywords: ["standard-product", "small-ticket", "standard", "low-value"],
         trait: "trust_sensitivity", value: "low", weight: 0.7 },
-    { keywords: ["subscription", "membership", "recurring", "subscription", "membership", "recurring"],
+    { keywords: ["subscription", "membership", "recurring"],
         trait: "consumption_frequency", value: "frequent", weight: 0.85 },
-    { keywords: ["course", "semester", "education", "course", "education"],
+    { keywords: ["course", "semester", "education"],
         trait: "consumption_frequency", value: "one_time", weight: 0.75 },
-    { keywords: ["daily", "frequent", "common", "daily", "frequent"],
+    { keywords: ["daily", "frequent", "common"],
         trait: "consumption_frequency", value: "frequent", weight: 0.75 },
-    { keywords: ["small-ticket", "daily", "convenience-store", "micro", "small-ticket"],
+    { keywords: ["small-ticket", "daily", "convenience-store", "micro"],
         trait: "avg_ticket_size", value: "micro", weight: 0.7 },
-    { keywords: ["retail", "commodity", "standard-product", "retail", "commodity"],
+    { keywords: ["retail", "commodity", "standard-product"],
         trait: "avg_ticket_size", value: "small", weight: 0.7 },
-    { keywords: ["custom", "project", "outsourcing", "custom", "project"],
+    { keywords: ["custom", "project", "outsourcing"],
         trait: "avg_ticket_size", value: "medium", weight: 0.7 },
-    { keywords: ["real-estate", "automobile", "high-value", "luxury", "realestate", "luxury", "car"],
+    { keywords: ["real-estate", "automobile", "high-value", "luxury", "realestate", "car"],
         trait: "avg_ticket_size", value: "large", weight: 0.85 },
 ];
 export const DEFAULT_TRAITS = {

package/dist/knowledge/machine-risk.js

@@ -133,7 +133,6 @@ export const MACHINE_RISK_RULES = [
             "to the Service. Disputes are then filed via arbitration::dispute(order, " +
             "arbitration) — completely independent of the machine workflow.",
         auto_fixable: false,
-        related_constraint: "dispute_independence_principle",
     },
     {
         id: "R-M2-01",

package/dist/knowledge/mcp-schema-audit.d.ts

@@ -10,7 +10,7 @@ export interface ToolDescriptor {
     input_schema_export: string;
     output_schema_export: string | null;
 }
-export declare const TOOLS_17: readonly ToolDescriptor[];
+export declare const ALL_TOOLS: readonly ToolDescriptor[];
 export type FindingSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
 export type FindingCategory = 'layer_census' | 'stub_inconsistency' | 'layer_parity' | 'any_unknown' | 'handler_types' | 'output_coverage' | 'generation_sync' | 'reflection';
 export interface Finding {

package/dist/knowledge/mcp-schema-audit.js

@@ -7,7 +7,7 @@ export const MCP_SRC_TOOLS_DIR = 'd:\\wowok\\agent\\mcp\\src\\tools';
 export const GENERATION_SCRIPT = 'd:\\wowok\\agent\\mcp\\scripts\\generate-json-schemas.ts';
 export const TOOLS_INDEX_FILE = 'd:\\wowok\\agent\\mcp\\src\\tools\\index.ts';
 export const MCP_SCHEMA_AUDIT_VERSION = '1.0.0';
-export const TOOLS_17 = [
+export const ALL_TOOLS = [
     { name: 'onchain_operations', input_schema_export: 'OnchainOperationsSchema', output_schema_export: 'CallOutputSchema' },
     { name: 'account_operation', input_schema_export: 'AccountOperationSchema', output_schema_export: 'AccountOperationOutputWrappedSchema' },
     { name: 'local_mark_operation', input_schema_export: 'LocalMarkOperationSchema', output_schema_export: 'LocalMarkOperationOutputWrappedSchema' },
@@ -25,6 +25,10 @@ export const TOOLS_17 = [
     { name: 'project_operation', input_schema_export: 'ProjectOperationInputSchema', output_schema_export: 'ProjectOperationOutputSchema' },
     { name: 'config_operation', input_schema_export: 'ConfigOperationInputSchema', output_schema_export: 'ConfigOperationOutputSchema' },
     { name: 'trust_score', input_schema_export: 'TrustScoreInputSchema', output_schema_export: 'TrustScoreOutputSchema' },
+    { name: 'query_task_status', input_schema_export: 'QueryTaskStatusInputSchema', output_schema_export: 'QueryTaskStatusOutputSchema' },
+    { name: 'evaluation_operation', input_schema_export: 'EvaluationOperationInputSchema', output_schema_export: 'EvaluationOperationOutputSchema' },
+    { name: 'persona_operation', input_schema_export: 'PersonaOperationInputSchema', output_schema_export: 'PersonaOperationOutputSchema' },
+    { name: 'intent_radar', input_schema_export: 'IntentRadarInputSchema', output_schema_export: 'IntentRadarOutputSchema' },
 ];
 export function loadLayer4Deployed(toolName) {
     const filePath = path.join(DEPLOYED_TOOLS_DIR, `${toolName}.json`);
@@ -98,7 +102,7 @@ export function loadLayer3Generated(toolName) {
 }
 export function analyzeLayerCensus() {
     const census = [];
-    for (const tool of TOOLS_17) {
+    for (const tool of ALL_TOOLS) {
         census.push({
             name: tool.name,
             layer2_zod: {
@@ -524,11 +528,11 @@ export function analyzeGenerationScriptSync() {
     const scriptNames = new Set();
     let m;
     while ((m = nameRegex.exec(src)) !== null) {
-        if (TOOLS_17.some(t => t.name === m[1])) {
+        if (ALL_TOOLS.some(t => t.name === m[1])) {
             scriptNames.add(m[1]);
         }
     }
-    for (const tool of TOOLS_17) {
+    for (const tool of ALL_TOOLS) {
         if (!scriptNames.has(tool.name)) {
             findings.push({
                 rule_id: 'MCP-GENSYNC-002',

package/dist/knowledge/service-risk.js

@@ -115,9 +115,45 @@ const R_S_1_04 = {
 const R_S_1_05 = {
     id: "R-S-1-05",
     category: "structural",
-    trigger: "Permission index not in Service range (300-320) used on Service object",
+    trigger: "sale.wip is a local path / localhost / LAN URL (not network-deployable) — every customer order fails",
     check: (ctx) => {
-        if (ctx.target_objects_types?.includes("Service")) {
+        if (ctx.sales && (ctx.sales.op === "add" || ctx.sales.op === "set")) {
+            for (const s of ctx.sales.sales) {
+                if (s.wip && s.wip !== "") {
+                    let localType = null;
+                    const w = s.wip;
+                    if (/^[A-Za-z]:[\\/]/.test(w) || w.startsWith("/") || w.startsWith("./") || w.startsWith("../")) {
+                        localType = "local filesystem path";
+                    }
+                    else if (/^https?:\/\/(localhost|127\.0\.0\.1|\[::1\]|0\.0\.0\.0)([:/]|$)/i.test(w)) {
+                        localType = "localhost/loopback URL";
+                    }
+                    else if (/^https?:\/\/(10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})([:/]|$)/i.test(w)) {
+                        localType = "LAN (private IP) URL";
+                    }
+                    else if (!/^https?:\/\//i.test(w) && !w.startsWith("ipfs://") && !w.startsWith("data:")) {
+                        localType = "unrecognized format (not a network URL)";
+                    }
+                    if (localType) {
+                        return {
+                            id: "R-S-1-05",
+                            level: "CRITICAL",
+                            category: "structural",
+                            title: "WIP is not network-deployed — every customer order will fail",
+                            description: `Sale "${s.name}" wip "${s.wip}" is a ${localType}. It passes set-time verification ` +
+                                `on the merchant's own machine but is unreachable by customers on other machines — ` +
+                                `order_new aborts 100% when a customer tries to buy.`,
+                            affected_stakeholders: ["owner", "customer"],
+                            scenario: "Merchant sets wip to a local file path / localhost / LAN URL and publishes the Service; " +
+                                "the on-chain wip points at the merchant's machine; customers cannot fetch it.",
+                            mitigation: "Deploy the .wip file to a public host (GitHub Pages, IPFS, or your own website) and set " +
+                                "sale.wip to the public URL. Or leave sale.wip empty (\"\") to skip WIP verification " +
+                                "(TESTING ONLY — not recommended for production).",
+                            evidence: `sale=${s.name}, wip=${s.wip}`,
+                        };
+                    }
+                }
+            }
         }
         return null;
     },

package/dist/knowledge/service-templates.js

@@ -9,7 +9,7 @@ export const SERVICE_TEMPLATES = [
             { name: "owner_address", type: "address", description: "Service owner address (receives payments)", required: true },
             { name: "permission_address", type: "address", description: "Permission object address (must be owned by owner)", required: true },
             { name: "description", type: "string", description: "Shop description", required: true },
-            { name: "location", type: "string", description: "Shop URL (HTTPS or IPFS)", required: false, default: "" },
+            { name: "location", type: "string", description: "Service geographic location (city/region)", required: false, default: "" },
             { name: "sales_items", type: "object", description: "Array of {name, price, stock, wip, wip_hash}", required: true },
             { name: "buy_guard_address", type: "address", description: "Buyer eligibility Guard (null for public sale)", required: false, default: "" },
         ],

package/dist/knowledge/service-translation.js

@@ -23,7 +23,7 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
         example_json: {
             object: "0xSERVICE_ADDRESS",
             description: "Updated description",
-            location: "https://shop.example.com",
+            location: "Shanghai",
             customer_required: ["name", "phone"],
         },
         reverse_explanation: "These fields are always mutable. customer_required is a string[] of field names buyers must provide at order time.",
@@ -241,7 +241,7 @@ export const SCHEMA_TO_SEMANTIC_RULES = [
     {
         element_type: "field",
         type_name: "location",
-        semantic_explanation: "Service URL/location (e.g. shop URL). Mutable. Index 303 (SERVICE_LOCATION).",
+        semantic_explanation: "Geographic location of the service (city/region). Mutable. Index 303 (SERVICE_LOCATION).",
     },
     {
         element_type: "field",

package/dist/knowledge/template-registry.d.ts

@@ -1,5 +1,5 @@
 export declare const TEMPLATE_REGISTRY_VERSION = 1;
-export type TemplateObjectType = "guard" | "machine" | "service" | "order" | "progress" | "arbitration" | "treasury" | "permission" | "passport" | "allocation" | "reward";
+export type TemplateObjectType = "guard" | "machine" | "service" | "order" | "progress" | "arbitration" | "treasury" | "permission" | "passport" | "allocation" | "reward" | "contact";
 export declare const TEMPLATE_OBJECT_TYPES: readonly TemplateObjectType[];
 export type UnifiedTemplateParamDefault = string | number | boolean | object | string[];
 export interface UnifiedTemplateParam {

package/dist/knowledge/template-registry.js

@@ -8,6 +8,7 @@ import { TREASURY_TEMPLATES, fillTemplate as fillTreasuryTemplate, } from "./tre
 import { PERMISSION_TEMPLATES, fillTemplate as fillPermissionTemplate, } from "./permission-templates.js";
 import { PASSPORT_TEMPLATES, fillTemplate as fillPassportTemplate, } from "./passport-templates.js";
 import { ALLOCATION_TEMPLATES, fillTemplate as fillAllocationTemplate, } from "./allocation-templates.js";
+import { CONTACT_TEMPLATES, fillTemplate as fillContactTemplate, } from "./contact-templates.js";
 import { REWARD_TEMPLATES, } from "./reward-templates.js";
 export const TEMPLATE_REGISTRY_VERSION = 1;
 export const TEMPLATE_OBJECT_TYPES = [
@@ -22,6 +23,7 @@ export const TEMPLATE_OBJECT_TYPES = [
     "passport",
     "allocation",
     "reward",
+    "contact",
 ];
 function normalizeParam(p) {
     return {
@@ -168,6 +170,13 @@ function buildRegistry() {
             },
         });
     }
+    for (const t of CONTACT_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "contact", t.applicable_scenes, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
     ID_COLLISIONS = collisions;
     return map;
 }
@@ -292,7 +301,8 @@ export function instantiateTemplate(templateId, params) {
         case "permission":
         case "passport":
         case "allocation":
-        case "progress": {
+        case "progress":
+        case "contact": {
             const r = fillBodyTemplate(objectType, templateId, params);
             if (!r.ok) {
                 return {
@@ -335,6 +345,8 @@ function fillBodyTemplate(objectType, templateId, params) {
             return fillAllocationTemplate(templateId, params);
         case "progress":
             return fillProgressTemplate(templateId, params);
+        case "contact":
+            return fillContactTemplate(templateId, params);
         default:
             return { ok: false, error: `No body-template fill for '${objectType}'` };
     }

package/dist/knowledge/tools-reference.js

@@ -127,6 +127,29 @@ export const TOOLS_REFERENCE = [
         summary: "Service trust & risk assessment — 5 trust dimensions + 4 risk dimensions.",
         notes: ["Use when user asks 'is this service trustworthy?' or 'should I buy?'."],
     },
+    {
+        name: "query_task_status",
+        summary: "Query async task status (build_graph / evaluate_project with async_mode).",
+        notes: ["Read-only; tasks are ephemeral (retained 5 min after completion)."],
+    },
+    {
+        name: "evaluation_operation",
+        summary: "Pluggable business evaluations — risk / match / compose / game with user injection.",
+        actions: ["service_risk", "demand_match", "service_match", "capability_gap", "compose_service", "node_game", "arb_game"],
+        notes: ["Read-only; the role decides and acts via onchain_operations."],
+    },
+    {
+        name: "persona_operation",
+        summary: "User identity setting (persona) — preferences, strategy, rules, spec; long-term + current layers.",
+        actions: ["get", "list", "set", "analyze", "apply", "remove"],
+        notes: ["Read/write local state; account persona overrides system; current overrides long-term."],
+    },
+    {
+        name: "intent_radar",
+        summary: "User business intent × chain event matching — persist intents, score events against them.",
+        actions: ["save", "list", "remove", "match"],
+        notes: ["Read-only w.r.t. chain; industry/keywords resolved once at save; events supplied or auto-pulled."],
+    },
 ];
 export function getToolReference(name) {
     return TOOLS_REFERENCE.find((t) => t.name === name);

package/dist/persona/analyzer.d.ts

@@ -0,0 +1,16 @@
+import type { Industry, PersonaRole } from "./types.js";
+export interface PersonaAnalysisSuggestion {
+    field: string;
+    value: unknown;
+    reason: string;
+}
+export interface PersonaAnalysis {
+    role?: PersonaRole;
+    industries: Industry[];
+    preferences: Record<string, unknown>;
+    requirements: string[];
+    rules: string[];
+    suggestions: PersonaAnalysisSuggestion[];
+    confidence: number;
+}
+export declare function analyzePersonaContext(context: string): PersonaAnalysis;

package/dist/persona/analyzer.js

@@ -0,0 +1,66 @@
+const INDUSTRY_KEYWORDS = {
+    freelance: ["freelance", "upwork"],
+    rental: ["rental", "airbnb"],
+    education: ["education", "coursera"],
+    travel: ["travel", "booking"],
+    subscription: ["subscription", "patreon"],
+    retail: ["retail", "amazon"],
+};
+const ROLE_KEYWORDS = {
+    merchant: ["merchant", "seller", "provider"],
+    user: ["user", "buyer", "customer"],
+    arbitrator: ["arbitrator"],
+};
+const RISK_KEYWORDS = {
+    conservative: ["conservative"],
+    aggressive: ["aggressive"],
+};
+export function analyzePersonaContext(context) {
+    const lower = context.toLowerCase();
+    const analysis = {
+        industries: [],
+        preferences: {},
+        requirements: [],
+        rules: [],
+        suggestions: [],
+        confidence: 0,
+    };
+    for (const [role, kws] of Object.entries(ROLE_KEYWORDS)) {
+        if (kws.some((k) => lower.includes(k))) {
+            analysis.role = role;
+            analysis.suggestions.push({ field: "role", value: role, reason: "role keyword matched" });
+            break;
+        }
+    }
+    for (const [ind, kws] of Object.entries(INDUSTRY_KEYWORDS)) {
+        if (kws.some((k) => lower.includes(k))) {
+            analysis.industries.push(ind);
+            analysis.suggestions.push({ field: "industries", value: ind, reason: "industry keyword matched" });
+        }
+    }
+    if (RISK_KEYWORDS.conservative.some((k) => lower.includes(k))) {
+        analysis.preferences.risk_appetite = "conservative";
+        analysis.suggestions.push({ field: "preferences.risk_appetite", value: "conservative", reason: "conservative keyword" });
+    }
+    else if (RISK_KEYWORDS.aggressive.some((k) => lower.includes(k))) {
+        analysis.preferences.risk_appetite = "aggressive";
+        analysis.suggestions.push({ field: "preferences.risk_appetite", value: "aggressive", reason: "aggressive keyword" });
+    }
+    const reqKeywords = ["must", "forbid", "never", "require"];
+    const ruleKeywords = ["learned", "avoid"];
+    for (const raw of context.split(/[;.\n]/)) {
+        const s = raw.trim();
+        if (!s)
+            continue;
+        if (reqKeywords.some((k) => s.toLowerCase().includes(k.toLowerCase()))) {
+            analysis.requirements.push(s);
+            analysis.suggestions.push({ field: "requirements", value: s, reason: "red-line keyword" });
+        }
+        else if (ruleKeywords.some((k) => s.toLowerCase().includes(k.toLowerCase()))) {
+            analysis.rules.push(s);
+            analysis.suggestions.push({ field: "rules", value: s, reason: "experience keyword" });
+        }
+    }
+    analysis.confidence = Math.min(1, analysis.suggestions.length * 0.2);
+    return analysis;
+}

package/dist/persona/bridge.d.ts

@@ -0,0 +1,5 @@
+import type { UserInjection } from "../evaluation/types.js";
+import type { EffectivePersona } from "./types.js";
+export declare function personaToInjection(effective: EffectivePersona): UserInjection;
+export declare function personaToContextText(effective: EffectivePersona): string;
+export declare function mergeInjections(base?: UserInjection | null, override?: UserInjection | null): UserInjection | undefined;