@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/knowledge/flywheel-loop.js

@@ -0,0 +1,378 @@
+import { aggregateIndustryMetrics, evaluateIndustryHealth, suggestIndustryUpdate, } from "./industry-evolution.js";
+import { getIndustryProfile, resolveIndustryName } from "./industry-registry.js";
+import { evaluateIndustryHealthByIntent, suggestIndustryUpdateByIntent, getRoleAdvice, filterSuggestionsByRole, getIntentProfile, } from "./intent-metrics.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+export const FLYWHEEL_LOOP_VERSION = 2;
+const MIN_SIGNALS_FOR_EVOLUTION = 10;
+const DEFAULT_SCHEDULE = {
+    mode: "manual",
+};
+const industrySchedules = new Map();
+const industryLastUpdate = new Map();
+const industryIntent = new Map();
+const signalBuffer = new Map();
+const decisionContexts = new Map();
+const latestMetrics = new Map();
+const latestHealth = new Map();
+const pendingSuggestions = new Map();
+export function recordIndustrySignal(industry, operation, outcome) {
+    if (!industry)
+        return;
+    const resolved = resolveIndustryName(industry) ?? industry;
+    const signal = {
+        industry: resolved,
+        operation_type: operation.type,
+        success: outcome.success,
+        error_code: outcome.error_code,
+        timestamp: Date.now(),
+    };
+    const list = signalBuffer.get(resolved) ?? [];
+    list.push(signal);
+    signalBuffer.set(resolved, list);
+    tryMaybeAutoTrigger(resolved, list.length);
+}
+function tryMaybeAutoTrigger(resolved, signalCount) {
+    const schedule = industrySchedules.get(resolved) ?? DEFAULT_SCHEDULE;
+    if (schedule.mode === "manual")
+        return;
+    const now = Date.now();
+    const lastUpdate = industryLastUpdate.get(resolved) ?? 0;
+    if (schedule.mode === "realtime") {
+        if (signalCount >= MIN_SIGNALS_FOR_EVOLUTION &&
+            signalCount % MIN_SIGNALS_FOR_EVOLUTION === 0) {
+            doAutoUpdate(resolved, schedule);
+        }
+        return;
+    }
+    if (schedule.mode === "semi_realtime") {
+        const threshold = schedule.signal_threshold ?? 20;
+        const interval = schedule.time_interval_ms ?? 5 * 60 * 1000;
+        const signalMet = signalCount >= threshold && signalCount % threshold === 0;
+        const timeMet = lastUpdate > 0 && (now - lastUpdate) >= interval;
+        if (signalMet || timeMet) {
+            doAutoUpdate(resolved, schedule);
+        }
+    }
+}
+function doAutoUpdate(resolved, schedule) {
+    try {
+        const result = updateIndustryCognition(resolved);
+        industryLastUpdate.set(resolved, Date.now());
+        if (schedule.auto_apply && result.suggestions_generated > 0) {
+            const suggestions = pendingSuggestions.get(resolved) ?? [];
+            const { applyIndustryUpdate } = require("./industry-evolution.js");
+            for (const s of suggestions) {
+                try {
+                    applyIndustryUpdate(resolved, s);
+                }
+                catch { }
+            }
+        }
+    }
+    catch {
+    }
+}
+export function setEvolutionSchedule(industry, config) {
+    if (!industry)
+        return;
+    const resolved = resolveIndustryName(industry) ?? industry;
+    industrySchedules.set(resolved, config);
+}
+export function getEvolutionSchedule(industry) {
+    const resolved = resolveIndustryName(industry) ?? industry;
+    return industrySchedules.get(resolved) ?? DEFAULT_SCHEDULE;
+}
+export function setIndustryIntent(industry, intent) {
+    if (!industry)
+        return;
+    const resolved = resolveIndustryName(industry) ?? industry;
+    industryIntent.set(resolved, intent);
+}
+export function getIndustryIntent(industry) {
+    const resolved = resolveIndustryName(industry) ?? industry;
+    return industryIntent.get(resolved) ?? "default";
+}
+export function getIndustrySignalCount(industry) {
+    const resolved = resolveIndustryName(industry) ?? industry;
+    return signalBuffer.get(resolved)?.length ?? 0;
+}
+export function getIndustrySignals(industry) {
+    const resolved = resolveIndustryName(industry) ?? industry;
+    return [...(signalBuffer.get(resolved) ?? [])];
+}
+export function listIndustriesWithSignals() {
+    return Array.from(signalBuffer.keys());
+}
+export function getPendingSuggestions(industry) {
+    const resolved = resolveIndustryName(industry) ?? industry;
+    return [...(pendingSuggestions.get(resolved) ?? [])];
+}
+export function recordDecisionContext(ctx, graph) {
+    if (!ctx.id || !ctx.node_id)
+        return;
+    decisionContexts.set(ctx.id, { ...ctx });
+    if (graph) {
+        try {
+            graph.attachDecisionContext(ctx.node_id, {
+                id: ctx.id,
+                decided_at: ctx.decided_at,
+                decider: ctx.decider,
+                industry: ctx.industry,
+                intent: ctx.intent,
+                alternatives: ctx.alternatives,
+                rationale: ctx.rationale,
+                outcome: ctx.outcome,
+            });
+        }
+        catch {
+        }
+    }
+}
+export function queryDecisionsByIndustry(industry) {
+    const resolved = resolveIndustryName(industry) ?? industry;
+    return Array.from(decisionContexts.values())
+        .filter((d) => d.industry === resolved)
+        .sort((a, b) => b.decided_at - a.decided_at);
+}
+export function queryDecisionsByNode(nodeId) {
+    return Array.from(decisionContexts.values())
+        .filter((d) => d.node_id === nodeId)
+        .sort((a, b) => b.decided_at - a.decided_at);
+}
+export function backfillDecisionOutcome(decisionId, outcome) {
+    const ctx = decisionContexts.get(decisionId);
+    if (!ctx)
+        return false;
+    ctx.outcome = outcome;
+    return true;
+}
+export function updateIndustryCognition(industry, rawData) {
+    const resolved = resolveIndustryName(industry) ?? industry;
+    const signals = signalBuffer.get(resolved) ?? [];
+    const result = {
+        industry: resolved,
+        metrics_updated: false,
+        health_recomputed: false,
+        suggestions_generated: 0,
+        evolution_ready: signals.length >= MIN_SIGNALS_FOR_EVOLUTION,
+    };
+    if (signals.length < MIN_SIGNALS_FOR_EVOLUTION && (!rawData || rawData.length === 0)) {
+        return result;
+    }
+    let metrics;
+    if (rawData && rawData.length > 0) {
+        metrics = aggregateIndustryMetrics(resolved, rawData);
+    }
+    else {
+        const synthesizedRaw = signals.map((s) => ({
+            industry: resolved,
+            completed: s.success,
+            has_dispute: !!s.error_code && s.error_code.includes("dispute"),
+            has_refund: !!s.error_code && s.error_code.includes("refund"),
+            ticket_size: 0n,
+            timestamp: s.timestamp,
+        }));
+        metrics = aggregateIndustryMetrics(resolved, synthesizedRaw);
+    }
+    latestMetrics.set(resolved, metrics);
+    result.metrics_updated = true;
+    const intent = industryIntent.get(resolved) ?? "default";
+    let health;
+    let suggestions;
+    if (intent !== "default") {
+        health = evaluateIndustryHealthByIntent(resolved, metrics, intent);
+        suggestions = suggestIndustryUpdateByIntent(resolved, metrics, intent);
+    }
+    else {
+        health = evaluateIndustryHealth(resolved, metrics);
+        suggestions = suggestIndustryUpdate(resolved, metrics);
+    }
+    latestHealth.set(resolved, health);
+    result.health_recomputed = true;
+    pendingSuggestions.set(resolved, suggestions);
+    result.suggestions_generated = suggestions.length;
+    return result;
+}
+export function injectEvolutionContext(_semantic, industry, role) {
+    if (!industry) {
+        return { confidence: 0 };
+    }
+    const resolved = resolveIndustryName(industry) ?? industry;
+    const profile = getIndustryProfile(resolved);
+    if (!profile) {
+        return {
+            confidence: 0,
+            industry_signal: `行业 ${resolved} 尚未注册，建议通过泛化引擎合成画像`,
+        };
+    }
+    const health = latestHealth.get(resolved);
+    const metrics = latestMetrics.get(resolved);
+    const suggestions = pendingSuggestions.get(resolved) ?? [];
+    const signalCount = signalBuffer.get(resolved)?.length ?? 0;
+    const intent = industryIntent.get(resolved) ?? "default";
+    const parts = [];
+    let advice;
+    let confidence = 0.5;
+    if (health) {
+        parts.push(`行业健康度 ${health.health_score}/100（${health.level}）`);
+        confidence = Math.max(confidence, 0.7);
+        if (health.weaknesses.length > 0) {
+            advice = `弱项：${health.weaknesses[0]}`;
+        }
+        if (health.recommendations.length > 0) {
+            advice = advice
+                ? `${advice}；建议：${health.recommendations[0]}`
+                : `建议：${health.recommendations[0]}`;
+        }
+    }
+    if (metrics && metrics.anomalies.length > 0) {
+        parts.push(`异常：${metrics.anomalies[0]}`);
+        confidence = Math.max(confidence, 0.8);
+    }
+    if (signalCount > 0) {
+        parts.push(`累积 ${signalCount} 个行业信号`);
+    }
+    if (intent !== "default") {
+        parts.push(`当前意图：${intent}`);
+    }
+    if (!advice && suggestions.length > 0) {
+        const highPriority = suggestions.find((s) => s.priority === "high") ?? suggestions[0];
+        advice = `${highPriority.suggestion_type}：${highPriority.evidence}`;
+        confidence = Math.max(confidence, highPriority.confidence);
+    }
+    let roleAdvice;
+    let filteredSuggestions = suggestions;
+    if (role) {
+        const intentSpec = getIntentProfile(intent);
+        if (intentSpec) {
+            roleAdvice = getRoleAdvice(intent, role);
+        }
+        const triggers = intentSpec?.suggestion_triggers ?? [];
+        filteredSuggestions = filterSuggestionsByRole(suggestions, role, triggers);
+        if (filteredSuggestions.length > 0) {
+            const topRole = filteredSuggestions.find((s) => s.priority === "high") ?? filteredSuggestions[0];
+            advice = `${topRole.suggestion_type}（${role}）：${topRole.evidence}`;
+        }
+    }
+    return {
+        industry_signal: parts.length > 0 ? parts.join("；") : undefined,
+        evolution_advice: advice,
+        confidence,
+        health_score: health?.health_score,
+        pending_suggestions: filteredSuggestions.length,
+        intent: intent !== "default" ? intent : undefined,
+        role_advice: roleAdvice && roleAdvice.length > 0 ? roleAdvice : undefined,
+        role,
+    };
+}
+export function getIndustryEvolutionStatus(industry) {
+    const resolved = resolveIndustryName(industry) ?? industry;
+    const profile = getIndustryProfile(resolved);
+    return {
+        industry: resolved,
+        version: profile?.version ?? "v0",
+        last_updated: profile?.evolution?.last_updated ?? 0,
+        signal_count: signalBuffer.get(resolved)?.length ?? 0,
+        health: latestHealth.get(resolved),
+        pending_suggestions: pendingSuggestions.get(resolved)?.length ?? 0,
+        evolution_ready: (signalBuffer.get(resolved)?.length ?? 0) >= MIN_SIGNALS_FOR_EVOLUTION,
+    };
+}
+export const EVOLUTION_STATE_VERSION = 1;
+function evolutionStateFilePath() {
+    const dir = process.env.WOWOK_CONFIG_DIR
+        ? process.env.WOWOK_CONFIG_DIR
+        : join(homedir(), ".wowok");
+    return join(dir, "evolution-state.json");
+}
+export function saveEvolutionState() {
+    const path = evolutionStateFilePath();
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const snap = {
+        version: EVOLUTION_STATE_VERSION,
+        saved_at: Date.now(),
+        signal_buffer: Object.fromEntries(signalBuffer),
+        decision_contexts: Object.fromEntries(decisionContexts),
+        latest_metrics: Object.fromEntries(latestMetrics),
+        latest_health: Object.fromEntries(latestHealth),
+        pending_suggestions: Object.fromEntries(pendingSuggestions),
+        industry_schedules: Object.fromEntries(industrySchedules),
+        industry_last_update: Object.fromEntries(industryLastUpdate),
+        industry_intent: Object.fromEntries(industryIntent),
+    };
+    const replacer = (_key, value) => {
+        if (typeof value === "bigint") {
+            return { __bigint__: value.toString() };
+        }
+        return value;
+    };
+    writeFileSync(path, JSON.stringify(snap, replacer, 2), "utf-8");
+    return path;
+}
+export function loadEvolutionState() {
+    const path = evolutionStateFilePath();
+    if (!existsSync(path))
+        return false;
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const reviver = (_key, value) => {
+            if (value && typeof value === "object" && "__bigint__" in value) {
+                return BigInt(value.__bigint__);
+            }
+            return value;
+        };
+        const snap = JSON.parse(raw, reviver);
+        if (!snap || snap.version !== EVOLUTION_STATE_VERSION)
+            return false;
+        _resetFlywheelLoopForTest();
+        for (const [k, v] of Object.entries(snap.signal_buffer)) {
+            signalBuffer.set(k, v);
+        }
+        for (const [k, v] of Object.entries(snap.decision_contexts)) {
+            decisionContexts.set(k, v);
+        }
+        for (const [k, v] of Object.entries(snap.latest_metrics)) {
+            latestMetrics.set(k, v);
+        }
+        for (const [k, v] of Object.entries(snap.latest_health)) {
+            latestHealth.set(k, v);
+        }
+        for (const [k, v] of Object.entries(snap.pending_suggestions)) {
+            pendingSuggestions.set(k, v);
+        }
+        for (const [k, v] of Object.entries(snap.industry_schedules)) {
+            industrySchedules.set(k, v);
+        }
+        for (const [k, v] of Object.entries(snap.industry_last_update)) {
+            industryLastUpdate.set(k, v);
+        }
+        for (const [k, v] of Object.entries(snap.industry_intent)) {
+            industryIntent.set(k, v);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasPersistedEvolutionState() {
+    return existsSync(evolutionStateFilePath());
+}
+export function _resetFlywheelLoopForTest() {
+    signalBuffer.clear();
+    decisionContexts.clear();
+    latestMetrics.clear();
+    latestHealth.clear();
+    pendingSuggestions.clear();
+    industrySchedules.clear();
+    industryLastUpdate.clear();
+    industryIntent.clear();
+}
+export function _snapshotSignalBuffer() {
+    return Object.fromEntries(signalBuffer);
+}
+export { MIN_SIGNALS_FOR_EVOLUTION as FLYWHEEL_LOOP_MIN_SIGNALS };

package/dist/knowledge/glossary.d.ts

@@ -0,0 +1,18 @@
+export type GlossaryCategory = "role" | "object" | "operation" | "acceptance" | "permission" | "fund";
+export interface GlossaryEntry {
+    term: string;
+    definition: string;
+    aliases: string[];
+    category: GlossaryCategory;
+}
+export declare const CONCEPT_GLOSSARY: GlossaryEntry[];
+export declare function resolveTerm(alias: string): string;
+export declare function lookupEntry(term: string): GlossaryEntry | undefined;
+export interface GlossaryDrift {
+    alias: string;
+    canonical: string;
+    line?: number;
+}
+export declare function validateText(text: string): GlossaryDrift[];
+export declare function auditSchemaFields(obj: Record<string, unknown>): GlossaryDrift[];
+export declare const CONCEPT_GLOSSARY_VERSION = 1;

package/dist/knowledge/glossary.js

@@ -0,0 +1,209 @@
+export const CONCEPT_GLOSSARY = [
+    {
+        term: "Permission",
+        definition: "Organization-wide permission object. indices 0-999 builtin, 1000-65535 custom. " +
+            "Shared across all Progress instances of a Service. Use for internal staff roles.",
+        aliases: ["permission object", "权限对象"],
+        category: "permission",
+    },
+    {
+        term: "NamedOperator",
+        definition: "Per-order role assignment inside a Progress. Each Progress node can map a role " +
+            "string to an address. Use for external collaborators whose identity varies per order.",
+        aliases: ["named operator", "namedoperator"],
+        category: "permission",
+    },
+    {
+        term: "OrderHolder",
+        definition: "The order holder and their agents. Represented by namedOperator=\"\" (empty string) " +
+            "on a Forward. Lets the customer operate their own order.",
+        aliases: ["order owner", "orderholder", "订单持有人"],
+        category: "permission",
+    },
+    {
+        term: "Forward",
+        definition: "A state-transition edge in a Machine. Carries weight, a permission " +
+            "(Permission index / NamedOperator / OrderHolder), and an optional Guard. " +
+            "Every Forward MUST define at least one permission.",
+        aliases: ["迁移", "transition"],
+        category: "operation",
+    },
+    {
+        term: "Pair",
+        definition: "A prev_node → next_node transition group in a Machine with a threshold. " +
+            "When the cumulative weight of executed Forwards meets the threshold, the Pair fires.",
+        aliases: ["迁移对", "transition pair"],
+        category: "operation",
+    },
+    {
+        term: "Machine",
+        definition: "Workflow blueprint (directed graph). Becomes immutable after publish. " +
+            "A Progress instance is created per order from the Machine.",
+        aliases: ["工作流模板", "machine template"],
+        category: "object",
+    },
+    {
+        term: "Progress",
+        definition: "A workflow instance bound to one order. Advances via Forwards; " +
+            "carries retained_submission values for Guard verification.",
+        aliases: ["流程实例", "progress instance"],
+        category: "object",
+    },
+    {
+        term: "Guard",
+        definition: "Immutable static validation rule. Verifies submissions and on-chain object data. " +
+            "Returns boolean. Cannot be mutated after creation.",
+        aliases: ["守卫", "guard object"],
+        category: "acceptance",
+    },
+    {
+        term: "Repository",
+        definition: "Mutable dynamic acceptance store. Keyed by (name, entity). " +
+            "Used for data that can change over time (e.g. SLA config, review records).",
+        aliases: ["仓库", "repository object"],
+        category: "acceptance",
+    },
+    {
+        term: "Acceptance",
+        definition: "The verification standard for a process step. Composed of static Guard + " +
+            "dynamic Repository. Drives whether a Forward can execute.",
+        aliases: ["验收标准", "acceptance standard"],
+        category: "acceptance",
+    },
+    {
+        term: "Service",
+        definition: "A merchant's service listing. References Machine, order_allocators, arbitrations, " +
+            "compensation_fund, rewards, buy_guard. machine & order_allocators lock after publish.",
+        aliases: ["服务", "service object"],
+        category: "object",
+    },
+    {
+        term: "Order",
+        definition: "An order against a Service. Funds are escrowed; released via Progress + Allocation. " +
+            "Arb cases attach to orders for dispute resolution.",
+        aliases: ["订单"],
+        category: "object",
+    },
+    {
+        term: "Allocator",
+        definition: "Fund distribution rules. Priority: Amount → Rate → Surplus. first-Guard-wins. " +
+            "Locked on Service publish (order_allocators).",
+        aliases: ["分账器", "allocation"],
+        category: "fund",
+    },
+    {
+        term: "Allocation",
+        definition: "The act of distributing escrowed funds to recipients per an Allocator. " +
+            "Executed by the order holder or Permission holder.",
+        aliases: ["分账"],
+        category: "fund",
+    },
+    {
+        term: "Arbitration",
+        definition: "Independent arbitration service object. Configured with voting_guard, usage_guard, " +
+            "fee. Generates Arb cases per dispute. Third-party preferred over self-built.",
+        aliases: ["仲裁服务", "arb service"],
+        category: "object",
+    },
+    {
+        term: "Arb",
+        definition: "A single dispute case instance of an Arbitration. Has a state machine " +
+            "(dispute → confirm → vote → verdict → settle).",
+        aliases: ["仲裁案", "arb case"],
+        category: "object",
+    },
+    {
+        term: "compensation_fund",
+        definition: "A fund attached to a Service. Arbitration indemnity is drawn from it. " +
+            "Adequacy is a key trust signal for customers.",
+        aliases: ["赔偿基金", "赔偿金"],
+        category: "fund",
+    },
+    {
+        term: "buy_guard",
+        definition: "A Guard attached to a Service that gates purchasing. Validates customer eligibility.",
+        aliases: ["购买守卫"],
+        category: "acceptance",
+    },
+    {
+        term: "Sub-Order",
+        definition: "A child order in a cross-Machine supply chain. Introduced at a node with transparent " +
+            "suppliers; verified by Guard to originate from one of the declared suppliers.",
+        aliases: ["采购子订单", "suborder", "sub order"],
+        category: "object",
+    },
+    {
+        term: "Reward",
+        definition: "Incentive pool. claim is Guard-gated. guard_add supports Fixed or GuardU64Identifier " +
+            "(dynamic). Used for marketing (first-order, cumulative, referral).",
+        aliases: ["奖励", "reward pool"],
+        category: "fund",
+    },
+    {
+        term: "Demand",
+        definition: "A user's posted service request with optional reward. presenters submit proposals; " +
+            "Guard filters them. Matches Services for personalized acquisition.",
+        aliases: ["需求"],
+        category: "object",
+    },
+    {
+        term: "Personal",
+        definition: "Permanently public on-chain identity profile. Social links, reputation (likes/dislikes), " +
+            "personal info records. CRITICAL: everything here is PUBLIC forever.",
+        aliases: ["公开身份", "personal profile"],
+        category: "object",
+    },
+    {
+        term: "Contact",
+        definition: "Bridges a Service's um (contact) and the Messenger ims (messaging). Enables " +
+            "off-chain encrypted communication for pre-order negotiation & evidence.",
+        aliases: ["联系"],
+        category: "object",
+    },
+];
+const ALIAS_INDEX = (() => {
+    const m = new Map();
+    for (const e of CONCEPT_GLOSSARY) {
+        m.set(e.term.toLowerCase(), e.term);
+        for (const a of e.aliases)
+            m.set(a.toLowerCase(), e.term);
+    }
+    return m;
+})();
+export function resolveTerm(alias) {
+    if (!alias)
+        return alias;
+    return ALIAS_INDEX.get(alias.toLowerCase()) ?? alias;
+}
+export function lookupEntry(term) {
+    const t = term.toLowerCase();
+    return CONCEPT_GLOSSARY.find((e) => e.term.toLowerCase() === t || e.aliases.some((a) => a.toLowerCase() === t));
+}
+export function validateText(text) {
+    const findings = [];
+    if (!text)
+        return findings;
+    const lower = text.toLowerCase();
+    for (const entry of CONCEPT_GLOSSARY) {
+        for (const alias of entry.aliases) {
+            const a = alias.toLowerCase();
+            if (entry.term.toLowerCase() === a)
+                continue;
+            if (lower.includes(a)) {
+                findings.push({ alias, canonical: entry.term });
+            }
+        }
+    }
+    return findings;
+}
+export function auditSchemaFields(obj) {
+    const findings = [];
+    for (const key of Object.keys(obj)) {
+        const canonical = ALIAS_INDEX.get(key.toLowerCase());
+        if (canonical && canonical !== key) {
+            findings.push({ alias: key, canonical });
+        }
+    }
+    return findings;
+}
+export const CONCEPT_GLOSSARY_VERSION = 1;

package/dist/knowledge/guard-ledger.d.ts

@@ -0,0 +1,19 @@
+export interface GuardScene {
+    id: string;
+    name: string;
+    host_object: "Service" | "Machine" | "Arbitration" | "Reward" | "Repository" | "Progress" | "Demand" | "Standalone";
+    binding_field: string;
+    validation_scene: string;
+    pass_result: string;
+    fail_result: string;
+    submission_source: string;
+    special_constraints: string[];
+    common_patterns: string[];
+    mutable_after_publish: boolean;
+    r_rounds_focus: string[];
+}
+export declare const GUARD_SCENES: GuardScene[];
+export declare function findScene(host_object: string, binding_field: string): GuardScene | undefined;
+export declare function inferSceneFromAction(action: "buy" | "forward" | "allocate" | "claim_reward" | "vote" | "dispute" | "write_repository" | "submit_progress"): GuardScene | undefined;
+export declare function getImmutableScenes(): GuardScene[];
+export declare function getNumericIdentifierScenes(): GuardScene[];