@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/knowledge/reward-templates.js

@@ -1,95 +1,95 @@
 export const REWARD_TEMPLATES = [
     {
         type: "first_order",
-        name: "首单奖励",
-        description: "新客户首次下单后获得奖励，降低尝试门槛，促进转化。",
-        guardCondition: "Guard 验证: order_address 的 holder == 当前 claim 者, 且 order.service == 本 Service, 且 order 是该 holder 的第一笔订单 (通过 Repository 查询历史)",
+        name: "First-order reward",
+        description: "New customers receive a reward after their first order, lowering the trial barrier and boosting conversion.",
+        guardCondition: "Guard verifies: order_address.holder == current claimer, and order.service == this Service, and order is the first order for this holder (via Repository history query)",
         amountRange: { min: "0.1WOW", max: "5WOW" },
         allocationStrategy: "fixed",
         parameters: [
-            { name: "amount", type: "string", description: "奖励金额 (如 '1WOW')", required: true },
-            { name: "budget", type: "string", description: "总预算 (如 '100WOW')", required: true },
+            { name: "amount", type: "string", description: "Reward amount (e.g., '1WOW')", required: true },
+            { name: "budget", type: "string", description: "Total budget (e.g., '100WOW')", required: true },
         ],
-        example: "新客户下单购买摄影服务，首单获得 1 WOW 返还，降低首次尝试成本。",
+        example: "A new customer orders a photography service and receives 1 WOW cashback on the first order, lowering the first trial cost.",
         relevantGuardOps: ["query", "repository_read"],
     },
     {
         type: "referral",
-        name: "裂变推荐奖励",
-        description: "老客户推荐新客户下单后，双方各获得奖励，形成口碑传播飞轮。",
-        guardCondition: "Guard 验证: 推荐人地址在 Repository 评价表中标记为 'referred_by', 且被推荐人的订单已完成 (Progress 到达终态)",
+        name: "Referral viral reward",
+        description: "Existing customers refer new customers to place an order; both parties receive a reward, creating a word-of-mouth flywheel.",
+        guardCondition: "Guard verifies: referrer address is marked as 'referred_by' in the Repository review table, and the referee's order is completed (Progress reached terminal state)",
         amountRange: { min: "0.5WOW", max: "10WOW" },
         allocationStrategy: "proportional",
         parameters: [
-            { name: "referrer_reward", type: "string", description: "推荐人奖励 (如 '2WOW')", required: true },
-            { name: "referee_reward", type: "string", description: "被推荐人奖励 (如 '1WOW')", required: true },
-            { name: "max_referrals", type: "number", description: "每人最多推荐数 (如 10)", required: false },
+            { name: "referrer_reward", type: "string", description: "Referrer reward (e.g., '2WOW')", required: true },
+            { name: "referee_reward", type: "string", description: "Referee reward (e.g., '1WOW')", required: true },
+            { name: "max_referrals", type: "number", description: "Max referrals per person (e.g., 10)", required: false },
         ],
-        example: "Alice 推荐 Bob 购买服务，Bob 完成首单后 Alice 得 2 WOW、Bob 得 1 WOW。",
+        example: "Alice refers Bob to purchase a service; after Bob completes the first order, Alice gets 2 WOW and Bob gets 1 WOW.",
         relevantGuardOps: ["query", "repository_read", "repository_write"],
     },
     {
         type: "loyalty",
-        name: "忠诚度阶梯奖励",
-        description: "客户累计消费达到阶梯后解锁更高奖励，提升复购率和客单价。",
-        guardCondition: "Guard 验证: 通过 Repository 查询该地址历史订单数 >= N, N 为当前阶梯阈值",
+        name: "Loyalty tiered reward",
+        description: "Customers unlock higher rewards after reaching cumulative spending tiers, improving repeat rate and average order value.",
+        guardCondition: "Guard verifies: via Repository query, the address's historical order count >= N, where N is the current tier threshold",
         amountRange: { min: "1WOW", max: "50WOW" },
         allocationStrategy: "tiered",
         parameters: [
-            { name: "tier1_orders", type: "number", description: "第一阶梯订单数 (如 3)", required: true },
-            { name: "tier1_reward", type: "string", description: "第一阶梯奖励 (如 '1WOW')", required: true },
-            { name: "tier2_orders", type: "number", description: "第二阶梯订单数 (如 10)", required: true },
-            { name: "tier2_reward", type: "string", description: "第二阶梯奖励 (如 '5WOW')", required: true },
-            { name: "tier3_orders", type: "number", description: "第三阶梯订单数 (如 30)", required: false },
-            { name: "tier3_reward", type: "string", description: "第三阶梯奖励 (如 '20WOW')", required: false },
+            { name: "tier1_orders", type: "number", description: "Tier 1 order count (e.g., 3)", required: true },
+            { name: "tier1_reward", type: "string", description: "Tier 1 reward (e.g., '1WOW')", required: true },
+            { name: "tier2_orders", type: "number", description: "Tier 2 order count (e.g., 10)", required: true },
+            { name: "tier2_reward", type: "string", description: "Tier 2 reward (e.g., '5WOW')", required: true },
+            { name: "tier3_orders", type: "number", description: "Tier 3 order count (e.g., 30)", required: false },
+            { name: "tier3_reward", type: "string", description: "Tier 3 reward (e.g., '20WOW')", required: false },
         ],
-        example: "客户累计 3 单得 1 WOW，10 单得 5 WOW，30 单得 20 WOW，激励持续消费。",
+        example: "A customer with 3 cumulative orders gets 1 WOW, 10 orders gets 5 WOW, 30 orders gets 20 WOW, incentivizing continued spending.",
         relevantGuardOps: ["query", "repository_read"],
     },
     {
         type: "flash_sale",
-        name: "限时闪购",
-        description: "在限定时间窗口内提供折扣或额外奖励，制造紧迫感促进即时转化。",
-        guardCondition: "Guard 验证: 当前区块时间在 [start_time, end_time] 范围内 (Guard 时间条件)",
+        name: "Limited-time flash sale",
+        description: "Provides discounts or extra rewards within a limited time window, creating urgency to drive instant conversion.",
+        guardCondition: "Guard verifies: current block time is within [start_time, end_time] range (Guard time condition)",
         amountRange: { min: "0.1WOW", max: "20WOW" },
         allocationStrategy: "fixed",
         parameters: [
-            { name: "start_time", type: "string", description: "开始时间 (Unix timestamp)", required: true },
-            { name: "end_time", type: "string", description: "结束时间 (Unix timestamp)", required: true },
-            { name: "amount", type: "string", description: "闪购奖励金额", required: true },
-            { name: "max_claims", type: "number", description: "最大领取数 (如 100)", required: true },
+            { name: "start_time", type: "string", description: "Start time (Unix timestamp)", required: true },
+            { name: "end_time", type: "string", description: "End time (Unix timestamp)", required: true },
+            { name: "amount", type: "string", description: "Flash sale reward amount", required: true },
+            { name: "max_claims", type: "number", description: "Max claims (e.g., 100)", required: true },
         ],
-        example: "周末限时 48 小时闪购，下单客户额外获得 2 WOW 返还，前 100 名有效。",
+        example: "Weekend 48-hour flash sale: ordering customers get an extra 2 WOW cashback, valid for the first 100.",
         relevantGuardOps: ["query", "time_condition"],
     },
     {
         type: "cashback",
-        name: "消费返现",
-        description: "客户完成订单后按消费比例返现，提升复购意愿。",
-        guardCondition: "Guard 验证: order 已到达终态 (Progress completed), 且 order.service == 本 Service",
+        name: "Spending cashback",
+        description: "Customers receive cashback proportional to spending after completing an order, improving repeat purchase willingness.",
+        guardCondition: "Guard verifies: order has reached terminal state (Progress completed), and order.service == this Service",
         amountRange: { min: "0.1WOW", max: "100WOW" },
         allocationStrategy: "proportional",
         parameters: [
-            { name: "cashback_rate", type: "string", description: "返现比例 (如 '0.1' = 10%)", required: true },
-            { name: "max_cashback", type: "string", description: "单笔最大返现 (如 '10WOW')", required: true },
-            { name: "budget", type: "string", description: "总预算 (如 '500WOW')", required: true },
+            { name: "cashback_rate", type: "string", description: "Cashback rate (e.g., '0.1' = 10%)", required: true },
+            { name: "max_cashback", type: "string", description: "Max cashback per order (e.g., '10WOW')", required: true },
+            { name: "budget", type: "string", description: "Total budget (e.g., '500WOW')", required: true },
         ],
-        example: "客户消费 10 WOW，按 10% 比例返现 1 WOW，下次消费可抵扣。",
+        example: "A customer spends 10 WOW, gets 10% cashback = 1 WOW, which can be deducted on the next purchase.",
         relevantGuardOps: ["query"],
     },
     {
         type: "milestone",
-        name: "里程碑奖励",
-        description: "Service 达到特定里程碑（如 100 单、1000 客户）时给早期支持者发放额外奖励。",
-        guardCondition: "Guard 验证: Repository 查询 Service 累计订单数 >= milestone_threshold, 且 claim 者为早期客户 (order_index < milestone)",
+        name: "Milestone reward",
+        description: "When a Service reaches a specific milestone (e.g., 100 orders, 1000 customers), early supporters receive extra rewards.",
+        guardCondition: "Guard verifies: Repository query shows Service cumulative order count >= milestone_threshold, and claimer is an early customer (order_index < milestone)",
         amountRange: { min: "1WOW", max: "100WOW" },
         allocationStrategy: "fixed",
         parameters: [
-            { name: "milestone", type: "number", description: "里程碑值 (如 100)", required: true },
-            { name: "reward_per_user", type: "string", description: "每人奖励 (如 '5WOW')", required: true },
-            { name: "max_recipients", type: "number", description: "最大受益人数 (如 50)", required: true },
+            { name: "milestone", type: "number", description: "Milestone value (e.g., 100)", required: true },
+            { name: "reward_per_user", type: "string", description: "Reward per person (e.g., '5WOW')", required: true },
+            { name: "max_recipients", type: "number", description: "Max beneficiaries (e.g., 50)", required: true },
         ],
-        example: "Service 达到 100 单里程碑，前 50 名客户每人获得 5 WOW 额外奖励。",
+        example: "Service reaches the 100-order milestone; the first 50 customers each receive 5 WOW extra reward.",
         relevantGuardOps: ["query", "repository_read"],
     },
 ];
@@ -102,22 +102,22 @@ export function listRewardTemplates() {
 }
 export function suggestRewardTemplate(intent) {
     const lower = intent.toLowerCase();
-    if (lower.includes("首单") || lower.includes("new") || lower.includes("first")) {
+    if (lower.includes("first order") || lower.includes("new") || lower.includes("first")) {
         return getRewardTemplate("first_order");
     }
-    if (lower.includes("推荐") || lower.includes("裂变") || lower.includes("referral")) {
+    if (lower.includes("referral") || lower.includes("viral") || lower.includes("referral")) {
         return getRewardTemplate("referral");
     }
-    if (lower.includes("复购") || lower.includes("忠诚") || lower.includes("loyalty")) {
+    if (lower.includes("repeat") || lower.includes("loyalty") || lower.includes("loyalty")) {
         return getRewardTemplate("loyalty");
     }
-    if (lower.includes("限时") || lower.includes("闪购") || lower.includes("flash")) {
+    if (lower.includes("limited-time") || lower.includes("flash") || lower.includes("flash")) {
         return getRewardTemplate("flash_sale");
     }
-    if (lower.includes("返现") || lower.includes("cashback")) {
+    if (lower.includes("cashback") || lower.includes("cashback")) {
         return getRewardTemplate("cashback");
     }
-    if (lower.includes("里程碑") || lower.includes("milestone")) {
+    if (lower.includes("milestone") || lower.includes("milestone")) {
         return getRewardTemplate("milestone");
     }
     return undefined;

package/dist/knowledge/safety-rules.js

@@ -146,8 +146,8 @@ export const CONFIRMATION_RULES = [
         bypass_on_explicit_intent: [
             "use default account",
             "default account is fine",
-            "用默认账户",
-            "用默认账户即可",
+            "use the default account",
+            "default account works fine",
         ],
     },
     {
@@ -209,7 +209,7 @@ export const CONFIRMATION_RULES = [
                 "gen_passport will consume gas for static testing",
             ],
         }),
-        bypass_on_explicit_intent: ["test guard", "测试 guard", "gen passport", "生成 passport"],
+        bypass_on_explicit_intent: ["test guard", "testing guard", "gen passport", "generate passport"],
     },
 ];
 function extractAmount(data) {

package/dist/knowledge/tool-constraints.js

@@ -26,8 +26,8 @@ export const TOOL_CONSTRAINTS = [
         constraints: [
             {
                 field: "node.nodes",
-                description: "Machine should have at least one node when published",
-                severity: "warning",
+                description: "Machine must have at least one node when published",
+                severity: "error",
                 check: (d) => {
                     if (typeof d?.object === "string")
                         return true;
@@ -61,7 +61,15 @@ export const TOOL_CONSTRAINTS = [
     },
     {
         operation_type: "order",
-        constraints: [],
+        constraints: [
+            {
+                field: "object",
+                description: "Order requires an existing Order object reference",
+                severity: "error",
+                check: (d) => !!d?.object,
+                message: () => "Order requires 'object' field (Order object ID or name).",
+            },
+        ],
     },
     {
         operation_type: "reward",
@@ -118,7 +126,15 @@ export const TOOL_CONSTRAINTS = [
     },
     {
         operation_type: "progress",
-        constraints: [],
+        constraints: [
+            {
+                field: "object",
+                description: "Progress requires an existing Progress object reference",
+                severity: "error",
+                check: (d) => !!d?.object,
+                message: () => "Progress requires 'object' field (Progress object ID or name).",
+            },
+        ],
     },
 ];
 const CONSTRAINT_INDEX = new Map(TOOL_CONSTRAINTS.map((c) => [c.operation_type, c]));

package/dist/knowledge/trust-metrics.js

@@ -1,9 +1,9 @@
 export const TRUST_METRICS_VERSION = 1;
 const TRUST_LEVELS = [
-    { min: 75, level: "trusted", label: "高信任" },
-    { min: 50, level: "moderate", label: "中等信任" },
-    { min: 25, level: "caution", label: "需注意" },
-    { min: 0, level: "high_risk", label: "高风险" },
+    { min: 75, level: "trusted", label: "High trust" },
+    { min: 50, level: "moderate", label: "Moderate trust" },
+    { min: 25, level: "caution", label: "Needs attention" },
+    { min: 0, level: "high_risk", label: "High risk" },
 ];
 export function computeServiceTrustScore(metrics) {
     const breakdown = [];
@@ -11,49 +11,49 @@ export function computeServiceTrustScore(metrics) {
     const arbScore = computeArbitrationDimension(metrics);
     breakdown.push(arbScore);
     if (arbScore.score < arbScore.maxScore * 0.3) {
-        warnings.push("仲裁信任分较低，建议检查仲裁记录");
+        warnings.push("Arbitration trust score is low; recommend checking arbitration records");
     }
     const reviewScore = computeReviewDimension(metrics);
     breakdown.push(reviewScore);
     if (reviewScore.score < reviewScore.maxScore * 0.3 && metrics.reviewStats) {
-        warnings.push(`好评率较低 (${metrics.reviewStats.likes}/${metrics.reviewStats.totalReviews})`);
+        warnings.push(`Low like rate (${metrics.reviewStats.likes}/${metrics.reviewStats.totalReviews})`);
     }
     const fulfillmentScore = computeFulfillmentDimension(metrics);
     breakdown.push(fulfillmentScore);
     if (metrics.completedRate !== undefined && metrics.completedRate < 0.7) {
-        warnings.push(`完成率仅 ${Math.round(metrics.completedRate * 100)}%`);
+        warnings.push(`Completion rate only ${Math.round(metrics.completedRate * 100)}%`);
     }
     const fundScore = computeFundDimension(metrics);
     breakdown.push(fundScore);
     if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
-        warnings.push("无赔偿金，客户权益保障不足");
+        warnings.push("No compensation fund; insufficient protection of customer rights");
     }
     const transparencyScore = computeTransparencyDimension(metrics);
     breakdown.push(transparencyScore);
     const totalScore = breakdown.reduce((sum, d) => sum + d.score, 0);
     const level = TRUST_LEVELS.find((l) => totalScore >= l.min)?.level ?? "high_risk";
-    const label = TRUST_LEVELS.find((l) => totalScore >= l.min)?.label ?? "高风险";
+    const label = TRUST_LEVELS.find((l) => totalScore >= l.min)?.label ?? "High risk";
     const summary = buildSummary(totalScore, label, metrics, breakdown);
     return { score: totalScore, level, breakdown, summary, warnings };
 }
 function computeArbitrationDimension(metrics) {
     const maxScore = 30;
     if (metrics.arbitrationScore === undefined) {
-        return { name: "arbitration", score: maxScore * 0.5, maxScore, description: "仲裁信任分（无数据，默认中等）", humanReadable: "仲裁记录: 无数据" };
+        return { name: "arbitration", score: maxScore * 0.5, maxScore, description: "Arbitration trust score (no data, default moderate)", humanReadable: "Arbitration record: no data" };
     }
     const score = Math.round((metrics.arbitrationScore / 100) * maxScore);
     return {
         name: "arbitration",
         score,
         maxScore,
-        description: `仲裁信任分 ${metrics.arbitrationScore}/100`,
-        humanReadable: `仲裁信任: ${metrics.arbitrationScore}/100${metrics.arbitrationCases !== undefined ? ` (${metrics.arbitrationCases} 案件)` : ""}`,
+        description: `Arbitration trust score ${metrics.arbitrationScore}/100`,
+        humanReadable: `Arbitration trust: ${metrics.arbitrationScore}/100${metrics.arbitrationCases !== undefined ? ` (${metrics.arbitrationCases} cases)` : ""}`,
     };
 }
 function computeReviewDimension(metrics) {
     const maxScore = 25;
     if (!metrics.reviewStats || metrics.reviewStats.totalReviews === 0) {
-        return { name: "reviews", score: maxScore * 0.5, maxScore, description: "评价声誉（无评价数据）", humanReadable: "评价: 无数据" };
+        return { name: "reviews", score: maxScore * 0.5, maxScore, description: "Review reputation (no review data)", humanReadable: "Reviews: no data" };
     }
     const { likes, dislikes, verifiedReviews, totalReviews } = metrics.reviewStats;
     const likeRate = likes / Math.max(1, totalReviews);
@@ -63,14 +63,14 @@ function computeReviewDimension(metrics) {
         name: "reviews",
         score: Math.min(maxScore, score),
         maxScore,
-        description: `好评率 ${Math.round(likeRate * 100)}% (${totalReviews} 条评价, ${verifiedReviews} 条带凭证)`,
-        humanReadable: `好评率 ${Math.round(likeRate * 100)}% (${totalReviews} 评价)`,
+        description: `Like rate ${Math.round(likeRate * 100)}% (${totalReviews} reviews, ${verifiedReviews} verified)`,
+        humanReadable: `Like rate ${Math.round(likeRate * 100)}% (${totalReviews} reviews)`,
     };
 }
 function computeFulfillmentDimension(metrics) {
     const maxScore = 20;
     if (metrics.orderCount === undefined) {
-        return { name: "fulfillment", score: maxScore * 0.5, maxScore, description: "履约记录（无订单数据）", humanReadable: "履约: 无数据" };
+        return { name: "fulfillment", score: maxScore * 0.5, maxScore, description: "Fulfillment record (no order data)", humanReadable: "Fulfillment: no data" };
     }
     let score = 0;
     const orderScore = Math.min(10, Math.floor(metrics.orderCount / 5));
@@ -85,14 +85,14 @@ function computeFulfillmentDimension(metrics) {
         name: "fulfillment",
         score: Math.min(maxScore, score),
         maxScore,
-        description: `已完成 ${metrics.orderCount} 单, 完成率 ${metrics.completedRate !== undefined ? Math.round(metrics.completedRate * 100) + "%" : "未知"}`,
-        humanReadable: `履约: ${metrics.orderCount} 单${metrics.avgCompletionTime !== undefined ? `, 平均 ${metrics.avgCompletionTime}h` : ""}`,
+        description: `Completed ${metrics.orderCount} orders, completion rate ${metrics.completedRate !== undefined ? Math.round(metrics.completedRate * 100) + "%" : "unknown"}`,
+        humanReadable: `Fulfillment: ${metrics.orderCount} orders${metrics.avgCompletionTime !== undefined ? `, avg ${metrics.avgCompletionTime}h` : ""}`,
     };
 }
 function computeFundDimension(metrics) {
     const maxScore = 15;
     if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
-        return { name: "fund_safety", score: 0, maxScore, description: "无赔偿金", humanReadable: "赔偿金: 无" };
+        return { name: "fund_safety", score: 0, maxScore, description: "No compensation fund", humanReadable: "Compensation fund: none" };
     }
     const threshold = 1000000000000n;
     const ratio = Number(metrics.compensationFundBalance * 100n / threshold) / 100;
@@ -101,8 +101,8 @@ function computeFundDimension(metrics) {
         name: "fund_safety",
         score,
         maxScore,
-        description: `赔偿金 ${metrics.compensationFundBalance} 最小单位`,
-        humanReadable: `赔偿金: 充足`,
+        description: `Compensation fund ${metrics.compensationFundBalance} smallest unit`,
+        humanReadable: `Compensation fund: sufficient`,
     };
 }
 function computeTransparencyDimension(metrics) {
@@ -118,12 +118,12 @@ function computeTransparencyDimension(metrics) {
         name: "transparency",
         score: Math.min(maxScore, score),
         maxScore,
-        description: `链上事件 ${metrics.hasPublishedEvents ? "✓" : "✗"}, Machine ${metrics.hasMachineBound ? "✓" : "✗"}, Guard ${metrics.hasBuyGuard ? "✓" : "✗"}`,
-        humanReadable: `透明度: ${["事件", "Machine", "Guard"].filter((_, i) => [metrics.hasPublishedEvents, metrics.hasMachineBound, metrics.hasBuyGuard][i]).join("+") || "无"}`,
+        description: `On-chain events ${metrics.hasPublishedEvents ? "✓" : "✗"}, Machine ${metrics.hasMachineBound ? "✓" : "✗"}, Guard ${metrics.hasBuyGuard ? "✓" : "✗"}`,
+        humanReadable: `Transparency: ${["Events", "Machine", "Guard"].filter((_, i) => [metrics.hasPublishedEvents, metrics.hasMachineBound, metrics.hasBuyGuard][i]).join("+") || "none"}`,
     };
 }
 function buildSummary(score, label, metrics, breakdown) {
-    const parts = [`信任分 ${score}/100 (${label})`];
+    const parts = [`Trust score ${score}/100 (${label})`];
     for (const d of breakdown) {
         parts.push(`${d.humanReadable}`);
     }
@@ -132,7 +132,7 @@ function buildSummary(score, label, metrics, breakdown) {
 export function quickTrustCheck(metrics) {
     const result = computeServiceTrustScore(metrics);
     if (result.score < 25) {
-        return { pass: false, reason: `信任分 ${result.score}/100，高风险: ${result.warnings.join("; ")}` };
+        return { pass: false, reason: `Trust score ${result.score}/100, high risk: ${result.warnings.join("; ")}` };
     }
-    return { pass: true, reason: `信任分 ${result.score}/100 (${result.level})` };
+    return { pass: true, reason: `Trust score ${result.score}/100 (${result.level})` };
 }

package/dist/project/graph.d.ts

@@ -3,6 +3,7 @@ export type EdgeKind = "machine" | "order_allocators" | "arbitrations" | "compen
 export interface GraphNode {
     id: string;
     project?: string;
+    projects?: string[];
     type?: ProjectObjectType;
     address?: string;
     decision_contexts?: GraphDecisionContext[];

package/dist/project/graph.js

@@ -1,3 +1,13 @@
+function matchesProjectFilter(nodeProject, filter) {
+    if (nodeProject === filter)
+        return true;
+    if (!filter.includes("_v")) {
+        const m = nodeProject.match(/^(.+)_v\d+$/);
+        if (m && m[1] === filter)
+            return true;
+    }
+    return false;
+}
 export class ProjectGraph {
     nodes = new Map();
     edges = [];
@@ -8,12 +18,17 @@ export class ProjectGraph {
     upsertNode(node) {
         const existing = this.nodes.get(node.id);
         if (existing) {
+            const mergedProjects = new Set([
+                ...(existing.projects ?? []),
+                ...(node.projects ?? []),
+            ]);
             this.nodes.set(node.id, {
                 ...existing,
                 ...node,
                 project: node.project ?? existing.project,
                 type: node.type ?? existing.type,
                 address: node.address ?? existing.address,
+                projects: mergedProjects.size > 0 ? Array.from(mergedProjects) : (existing.projects ?? node.projects),
             });
             return this.nodes.get(node.id);
         }
@@ -79,7 +94,18 @@ export class ProjectGraph {
         const all = Array.from(this.nodes.values());
         if (!projectPrefix)
             return all;
-        return all.filter((n) => n.project === projectPrefix);
+        return all.filter((n) => {
+            if (n.projects && n.projects.length > 0) {
+                return n.projects.some((p) => matchesProjectFilter(p, projectPrefix));
+            }
+            if (!n.project)
+                return false;
+            if (n.project === projectPrefix)
+                return true;
+            if (projectPrefix.startsWith(n.project + "_v"))
+                return true;
+            return false;
+        });
     }
     getDependencies(id) {
         const idxs = this.outEdges.get(id);

package/dist/project/index.d.ts

@@ -32,6 +32,7 @@ export declare function queryProjectObjects(prefix: string): Promise<{
     name?: string;
     address?: string;
     type?: string;
+    version?: string;
 }[]>;
 export declare function queryShareableObjects(): Promise<{
     name?: string;

package/dist/project/index.js

@@ -1,7 +1,8 @@
-import { normalizeForProject, extractProjectPrefix, TAG_PREFIX, } from "./namespace.js";
+import { normalizeForProject, extractProjectPrefix, extractAllProjectVersions, TAG_PREFIX, } from "./namespace.js";
 import { ProjectGraph, extractReferences, nodeIdOf, } from "./graph.js";
 import { listProjects, listProjectObjects, listShareableObjects, traceDependencies, traceReferencedBy, prePublishCheck, findCrossProjectReferences, } from "./query.js";
 import { isEnabled as isRuntimeEnabled } from "../config/index.js";
+import { LocalMark } from "@wowok/wowok";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { dirname, join } from "path";
 import { homedir } from "os";
@@ -11,6 +12,33 @@ export * from "./query.js";
 export function isProjectServiceEnabled() {
     return isRuntimeEnabled("project_service");
 }
+function scheduleHiddenStep(sourceNodeId, sourceTags, references) {
+    const versionedTags = extractAllProjectVersions(sourceTags)
+        .filter((p) => p.version !== undefined)
+        .map((p) => `${TAG_PREFIX.project}${p.prefix}_${p.version}`);
+    if (versionedTags.length === 0 || references.length === 0)
+        return;
+    const run = async () => {
+        const localMark = LocalMark.Instance();
+        for (const ref of references) {
+            try {
+                await localMark.add_tags(ref.target, versionedTags);
+            }
+            catch {
+            }
+        }
+    };
+    if (typeof setImmediate === "function") {
+        setImmediate(() => {
+            run().catch(() => { });
+        });
+    }
+    else {
+        Promise.resolve().then(() => {
+            run().catch(() => { });
+        });
+    }
+}
 let GRAPH_INSTANCE = null;
 let GRAPH_HYDRATED = false;
 function isAutoHydrateEnabled() {
@@ -63,12 +91,21 @@ export function observe(operation_type, data, result) {
         const project = extractProjectPrefix(tags);
         const typeTag = tags?.find((t) => t.startsWith(TAG_PREFIX.type));
         const type = typeTag?.slice(TAG_PREFIX.type.length);
-        const node = { id: nodeId, project, type, address };
+        const projectEntries = extractAllProjectVersions(tags);
+        const projects = projectEntries.map((p) => p.version ? `${p.prefix}_${p.version}` : p.prefix);
+        const node = {
+            id: nodeId,
+            project,
+            projects: projects.length > 0 ? projects : undefined,
+            type,
+            address,
+        };
         graph.upsertNode(node);
         const refs = extractReferences(operation_type, data);
         for (const r of refs) {
             graph.addEdge(nodeId, r.target, r.kind);
         }
+        scheduleHiddenStep(nodeId, tags, refs);
         if (isRuntimeEnabled("graph_persist")) {
             try {
                 saveGraph();

package/dist/project/namespace.d.ts

@@ -39,6 +39,16 @@ export interface TagInjectionOptions {
     existingTags?: string[];
 }
 export declare function buildProjectTags(opts: TagInjectionOptions): string[];
+export declare function parseProjectTagValue(value: string): {
+    prefix: string;
+    version?: string;
+};
+export interface ProjectTagEntry {
+    prefix: string;
+    version?: string;
+    raw: string;
+}
+export declare function extractAllProjectVersions(tags: string[] | undefined): ProjectTagEntry[];
 export declare function extractProjectPrefix(tags: string[] | undefined): string | undefined;
 export interface NormalizeResult {
     data: any;
@@ -59,4 +69,4 @@ export interface NormalizeInput {
     shareable?: boolean;
 }
 export declare function normalizeForProject(input: NormalizeInput): NormalizeResult;
-export declare const NAMESPACE_VERSION = 1;
+export declare const NAMESPACE_VERSION = 2;

package/dist/project/namespace.js

@@ -101,6 +101,9 @@ export function buildProjectTags(opts) {
     const tags = new Set(opts.existingTags ?? []);
     if (opts.projectPrefix) {
         tags.add(`${TAG_PREFIX.project}${opts.projectPrefix}`);
+        if (opts.version) {
+            tags.add(`${TAG_PREFIX.project}${opts.projectPrefix}_${opts.version}`);
+        }
     }
     if (opts.type) {
         tags.add(`${TAG_PREFIX.type}${opts.type}`);
@@ -119,12 +122,34 @@ export function buildProjectTags(opts) {
     }
     return Array.from(tags);
 }
+export function parseProjectTagValue(value) {
+    const m = value.match(/^(.+?)_(v\d+)$/);
+    if (m) {
+        return { prefix: m[1], version: m[2] };
+    }
+    return { prefix: value };
+}
+export function extractAllProjectVersions(tags) {
+    if (!tags)
+        return [];
+    const result = [];
+    for (const t of tags) {
+        if (!t.startsWith(TAG_PREFIX.project))
+            continue;
+        const value = t.slice(TAG_PREFIX.project.length);
+        const parsed = parseProjectTagValue(value);
+        result.push({ ...parsed, raw: t });
+    }
+    return result;
+}
 export function extractProjectPrefix(tags) {
     if (!tags)
         return undefined;
     for (const t of tags) {
         if (t.startsWith(TAG_PREFIX.project)) {
-            return t.slice(TAG_PREFIX.project.length);
+            const value = t.slice(TAG_PREFIX.project.length);
+            const parsed = parseProjectTagValue(value);
+            return parsed.prefix;
         }
     }
     return undefined;
@@ -178,4 +203,4 @@ export function normalizeForProject(input) {
         project: { prefix, type: inferredType, version },
     };
 }
-export const NAMESPACE_VERSION = 1;
+export const NAMESPACE_VERSION = 2;

package/dist/project/query.d.ts

@@ -3,10 +3,12 @@ export interface ProjectInfo {
     prefix: string;
     objectCount: number;
     types: string[];
+    versions?: string[];
     objects: Array<{
         name?: string;
         address?: string;
         type?: string;
+        version?: string;
     }>;
 }
 export interface DependencyTrace {