@wowok/agent-mcp 2.6.9 → 2.7.1

package/dist/project/handlers.js

@@ -888,10 +888,32 @@ export async function handleGetGraph(v) {
 }
 export async function handleEvaluateProject(v) {
     const projectId = await resolveProjectId(v);
-    const evalType = requireField(v.evaluation_type, "evaluation_type");
     const project = await localProject.getProject(projectId);
     if (!project)
         throw new Error(`Project not found: ${projectId}`);
+    if (v.async_mode === true) {
+        const taskId = TaskTracker.create("evaluate_project", projectId);
+        (async () => {
+            try {
+                TaskTracker.update(taskId, 10, "Refreshing objects and gathering inputs");
+                const result = await evaluateProjectSync(projectId, project, v);
+                TaskTracker.complete(taskId, result);
+            }
+            catch (err) {
+                TaskTracker.fail(taskId, err.message ?? String(err));
+            }
+        })();
+        return {
+            action: "evaluate_project",
+            async_mode: true,
+            task_id: taskId,
+            hint: "Evaluation is running in the background. Call query_task_status with task_id to check progress and retrieve the result.",
+        };
+    }
+    return evaluateProjectSync(projectId, project, v);
+}
+async function evaluateProjectSync(projectId, project, v) {
+    const evalType = requireField(v.evaluation_type, "evaluation_type");
     let refreshWarning;
     if (v.refresh_before_eval !== false) {
         const refreshResult = await refreshProjectObjects(projectId, project.network);

package/dist/project/semantic-graph.js

@@ -147,6 +147,53 @@ export function buildSemanticGraph(intent, adoptedModules) {
             }
         }
     }
+    if (intent.intent.startsWith("sell_") || intent.intent === "rent_asset") {
+        nodes.push({
+            id: "main_contact",
+            type: "contact",
+            purpose: "Public contact/IM channel so customers can reach the merchant before ordering",
+            derivedFrom: { intentField: "description", rationale: "A discoverable contact object improves customer trust and order conversion" },
+            config: {
+                name: { type: "string", value: `${intent.description.slice(0, 20)}_contact`, mapsTo: "object.name" },
+                description: { type: "string", value: intent.description, mapsTo: "object.description" },
+            },
+            expectedState: { published: true, paused: false },
+        });
+        const svc = nodes.find((n) => n.id === "main_service");
+        if (svc) {
+            svc.config["um"] = { type: "address_ref", targetId: "main_contact", mapsTo: "object.um" };
+            edges.push({
+                from: "main_service",
+                to: "main_contact",
+                relation: "has_contact",
+                required: false,
+                derivedFrom: { intentField: "description", rationale: "Service binds Contact via um so customers can reach the merchant" },
+            });
+        }
+    }
+    if (intent.intent.startsWith("sell_") || intent.intent === "rent_asset") {
+        nodes.push({
+            id: "main_reward",
+            type: "reward",
+            purpose: "Optional incentive pool (discount/referral) to attract and retain customers",
+            derivedFrom: { intentField: "payment", rationale: "Rewards lower acquisition cost and boost conversion" },
+            config: {
+                name: { type: "string", value: `${intent.description.slice(0, 20)}_reward`, mapsTo: "object.name" },
+                type_parameter: { type: "string", value: intent.payment.currency, mapsTo: "object.type_parameter" },
+                permission: { type: "address_ref", targetId: "main_permission", mapsTo: "object.permission" },
+            },
+            expectedState: { published: true, paused: false },
+        });
+        if (nodes.find((n) => n.id === "main_service")) {
+            edges.push({
+                from: "main_service",
+                to: "main_reward",
+                relation: "has_rewards",
+                required: false,
+                derivedFrom: { intentField: "payment", rationale: "Service can reference Reward in its rewards list" },
+            });
+        }
+    }
     constraints.push({
         id: "service_permission_bound",
         level: "hard",

package/dist/rules.d.ts

@@ -10,3 +10,5 @@ export { Harness, getHarness, setHarness } from "./harness/index.js";
 export type { ODG, ExpectedResult, VerifyReport, RecoveryAction, Checkpoint, } from "./harness/types.js";
 export { getDefaultPreferences, inferPreferences, matchServiceToPreferences, mergePreferences, validatePreferences, SUPPORTED_INDUSTRIES, type IndustryTemplate, type Industry, type PreferenceInference, type ServiceForMatching, type PreferenceMatchResult, } from "./customer/user-preferences.js";
 export type { UserPreferences } from "./customer/types.js";
+export declare function buildSoftRulesPrompt(): string;
+export { OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_TYPE_CLASSIFICATION, OPERATION_CLASS_META, NAMING_CONVENTIONS, classifyTool, checkObjectReuseRules, checkImmutabilityRules, type ObjectReuseRule, type ImmutabilityRule, type OperationClass, type OperationClassMeta, type ReuseRecommendation, type SafetyRiskItem, } from "./knowledge/safety-rules.js";

package/dist/rules.js

@@ -7,3 +7,46 @@ export { CONFIRMATION_RULES, SAFETY_RULES_VERSION, DEFAULT_AMOUNT_THRESHOLD, get
 export { distillIntent, extractSignals } from "./experience/intent-distill.js";
 export { Harness, getHarness, setHarness } from "./harness/index.js";
 export { getDefaultPreferences, inferPreferences, matchServiceToPreferences, mergePreferences, validatePreferences, SUPPORTED_INDUSTRIES, } from "./customer/user-preferences.js";
+import { CONFIRMATION_RULES, DEFAULT_AMOUNT_THRESHOLD, formatAmount, OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_CLASS_META, NAMING_CONVENTIONS, } from "./knowledge/safety-rules.js";
+const PERMISSION_INDEX_RANGE = "1000-65535 (0-999 reserved)";
+export function buildSoftRulesPrompt() {
+    const lines = [];
+    lines.push("## Token amounts");
+    lines.push("- Token amounts are U64 integers in the smallest unit. 1 WOW = 1_000_000_000 (9 decimals).");
+    lines.push("- Amount input accepts '2WOW' / '10.5WOW' (auto-converted) or a raw integer '2000000000'.");
+    lines.push("- Always query token precision via query_toolkit before using a non-WOW token.");
+    lines.push("");
+    lines.push("## Operation classes");
+    for (const [cls, meta] of Object.entries(OPERATION_CLASS_META)) {
+        lines.push(`- ${cls}: ${meta.note}`);
+    }
+    lines.push("");
+    lines.push("## Object reuse vs create");
+    lines.push(`- ${CREATE_VS_MODIFY_PATTERN.note}`);
+    for (const r of OBJECT_REUSE_RULES) {
+        lines.push(`  - ${r.object_type}: ${r.recommendation.replace(/_/g, " ")} — ${r.reason}`);
+    }
+    lines.push("");
+    lines.push("## Immutability");
+    for (const r of IMMUTABILITY_RULES) {
+        const mutable = r.mutable_after?.length
+            ? ` (still mutable: ${r.mutable_after.join(", ")})`
+            : "";
+        lines.push(`- ${r.object_type} ${r.trigger}: ${r.message}${mutable}`);
+    }
+    lines.push("");
+    lines.push("## Confirmation levels");
+    const levels = [...new Set(CONFIRMATION_RULES.map((r) => r.level))];
+    lines.push(`- Amount threshold for extra scrutiny: ${formatAmount(DEFAULT_AMOUNT_THRESHOLD)} WOW.`);
+    lines.push(`- Confirm-gate levels: ${levels.join(", ")}.`);
+    lines.push("");
+    lines.push("## Naming conventions");
+    lines.push(`- Scheme: ${NAMING_CONVENTIONS.scheme}`);
+    for (const rec of NAMING_CONVENTIONS.recommendations) {
+        lines.push(`- ${rec}`);
+    }
+    lines.push(`- Custom permission indices: ${PERMISSION_INDEX_RANGE}.`);
+    lines.push("");
+    return lines.join("\n");
+}
+export { OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_TYPE_CLASSIFICATION, OPERATION_CLASS_META, NAMING_CONVENTIONS, classifyTool, checkObjectReuseRules, checkImmutabilityRules, } from "./knowledge/safety-rules.js";

package/dist/schema/call/semantic.js

@@ -893,6 +893,18 @@ const EVENT_SEMANTIC_RULES = [
         business_meaning: "Order progress was updated",
         category: "state_change",
     },
+    {
+        pattern: /::demand::DemandFeedbackEvent|::demand::FeedbackEvent/i,
+        business_meaning: "A demand owner gave feedback (acceptance score) on a presented service",
+        category: "state_change",
+        side_effect: "High acceptance score signals a strong service↔demand fit; low score signals a mismatch",
+    },
+    {
+        pattern: /::entity::NewEntityEvent|::entity::EntityRegisteredEvent|::registrar::NewEntityEvent/i,
+        business_meaning: "A new on-chain entity (user/merchant) was registered",
+        category: "lifecycle",
+        side_effect: "A new potential counterparty entered the ecosystem",
+    },
 ];
 function extractRelatedObject(event) {
     if (!event || typeof event !== "object")
@@ -907,9 +919,19 @@ function extractRelatedObject(event) {
     }
     return undefined;
 }
+const BUILTIN_EVENT_TYPE_MAP = {
+    NewOrderEvent: "::order::OrderCreatedEvent",
+    ArbEvent: "::arbitration::ArbitrationRequestedEvent",
+    ProgressEvent: "::progress::ProgressUpdatedEvent",
+    DemandPresentEvent: "::demand::PresenterSubmittedEvent",
+    DemandFeedbackEvent: "::demand::DemandFeedbackEvent",
+    NewEntityEvent: "::entity::NewEntityEvent",
+};
 export function eventToSemantic(event) {
     const eventType = String(event?.type ?? event?.event_type ?? "");
-    const rule = EVENT_SEMANTIC_RULES.find((r) => r.pattern.test(eventType));
+    const typeRaw = String(event?.type_raw ?? "");
+    const candidates = [typeRaw, eventType, BUILTIN_EVENT_TYPE_MAP[eventType] ?? ""].filter(Boolean);
+    const rule = EVENT_SEMANTIC_RULES.find((r) => candidates.some((c) => r.pattern.test(c)));
     if (!rule) {
         return {
             event_type: eventType,

package/dist/schema/call/service.js

@@ -69,7 +69,13 @@ export const CallService_DataSchema = z.object({
     order_new: OrderNewSchema.optional().describe("Create new order."),
     description: DescriptionSchema.optional(),
     location: LongNameSchema.optional().describe("Location of the Service"),
-    sales: SalesSchema.optional().describe("Service sales products or services list."),
+    sales: SalesSchema.optional().describe("Service sales products or services list. " +
+        "⚠️ WIP NETWORK-DEPLOYMENT RULE: a non-empty sale.wip MUST be a publicly reachable URL " +
+        "(GitHub Pages / IPFS / your own website). The URL is stored ON-CHAIN and every customer " +
+        "fetches it at order time — a local file path, localhost/loopback URL, or LAN private-IP URL " +
+        "is unreachable by customers on other machines and aborts order_new 100%. Local-network URLs " +
+        "are INTERNAL TEST USE ONLY (env.network = localnet). Leave sale.wip empty (\"\") to skip " +
+        "WIP verification (TESTING ONLY)."),
     repositories: ObjectsSchema.optional().describe("Service Repository object list."),
     rewards: ObjectsSchema.optional().describe("Service Reward object list. " +
         "May share the Service's Permission (no conflict check — intentional: rewards are the provider's own " +