@wowok/agent-mcp 2.5.2 → 2.5.4

package/dist/knowledge/trust-metrics.js

@@ -38,16 +38,51 @@ export function computeServiceTrustScore(metrics) {
 }
 function computeArbitrationDimension(metrics) {
     const maxScore = 30;
-    if (metrics.arbitrationScore === undefined) {
-        return { name: "arbitration", score: maxScore * 0.5, maxScore, description: "Arbitration trust score (no data, default moderate)", humanReadable: "Arbitration record: no data" };
+    if (metrics.arbitrationScore === undefined && metrics.arbitrationVotingGuardCount === undefined) {
+        return {
+            name: "arbitration",
+            score: maxScore * 0.25,
+            maxScore,
+            description: "Arbitration trust score (no data; default low because arbitration is critical)",
+            humanReadable: "Arbitration: no data (default low — critical missing)",
+        };
     }
-    const score = Math.round((metrics.arbitrationScore / 100) * maxScore);
+    let score = 0;
+    const parts = [];
+    if (metrics.arbitrationScore !== undefined) {
+        const baseScore = Math.round((metrics.arbitrationScore / 100) * 10);
+        score += baseScore;
+        parts.push(`score ${metrics.arbitrationScore}/100`);
+    }
+    else {
+        score += 3;
+    }
+    if (metrics.arbitrationVotingGuardCount !== undefined && metrics.arbitrationVotingGuardCount > 0) {
+        score += 5;
+        parts.push(`${metrics.arbitrationVotingGuardCount} voting_guard(s)`);
+    }
+    if (metrics.arbitrationFeeBalance !== undefined && metrics.arbitrationFeeBalance > 0n) {
+        score += 5;
+        parts.push("fee funded");
+    }
+    if (metrics.arbitrationPaused === false) {
+        score += 5;
+        parts.push("active");
+    }
+    else if (metrics.arbitrationPaused === true) {
+        parts.push("paused");
+    }
+    if (metrics.arbitrationCases !== undefined && metrics.arbitrationCases > 0) {
+        score += 5;
+        parts.push(`${metrics.arbitrationCases} case(s)`);
+    }
+    score = Math.min(maxScore, score);
     return {
         name: "arbitration",
         score,
         maxScore,
-        description: `Arbitration trust score ${metrics.arbitrationScore}/100`,
-        humanReadable: `Arbitration trust: ${metrics.arbitrationScore}/100${metrics.arbitrationCases !== undefined ? ` (${metrics.arbitrationCases} cases)` : ""}`,
+        description: `Arbitration config: ${parts.join(", ")}`,
+        humanReadable: `Arbitration: ${parts.join(", ")}`,
     };
 }
 function computeReviewDimension(metrics) {
@@ -94,6 +129,31 @@ function computeFundDimension(metrics) {
     if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
         return { name: "fund_safety", score: 0, maxScore, description: "No compensation fund", humanReadable: "Compensation fund: none" };
     }
+    const fund = metrics.compensationFundBalance;
+    if (metrics.typicalOrderAmount !== undefined && metrics.typicalOrderAmount > 0n) {
+        const ratio = Number((fund * 100n) / metrics.typicalOrderAmount) / 100;
+        let score;
+        let humanReadable;
+        if (ratio >= 10) {
+            score = maxScore;
+            humanReadable = `Compensation fund: ${ratio.toFixed(1)}x order amount (excellent)`;
+        }
+        else if (ratio >= 1) {
+            score = 10 + Math.round((ratio - 1) / 9 * 5);
+            humanReadable = `Compensation fund: ${ratio.toFixed(1)}x order amount (covers ≥1 payout)`;
+        }
+        else {
+            score = Math.round(ratio * 10);
+            humanReadable = `Compensation fund: ${ratio.toFixed(1)}x order amount (insufficient)`;
+        }
+        return {
+            name: "fund_safety",
+            score: Math.min(maxScore, score),
+            maxScore,
+            description: `Fund ${fund.toString()} / typical order ${metrics.typicalOrderAmount.toString()} = ${ratio.toFixed(2)}x`,
+            humanReadable,
+        };
+    }
     const threshold = 1000000000000n;
     const ratio = Number(metrics.compensationFundBalance * 100n / threshold) / 100;
     const score = Math.min(maxScore, Math.round(ratio * maxScore));
@@ -101,8 +161,8 @@ function computeFundDimension(metrics) {
         name: "fund_safety",
         score,
         maxScore,
-        description: `Compensation fund ${metrics.compensationFundBalance} smallest unit`,
-        humanReadable: `Compensation fund: sufficient`,
+        description: `Compensation fund ${metrics.compensationFundBalance} smallest unit (absolute threshold fallback)`,
+        humanReadable: `Compensation fund: ${ratio.toFixed(2)}x absolute threshold`,
     };
 }
 function computeTransparencyDimension(metrics) {

package/dist/loop-engineering/context-collect.d.ts

@@ -0,0 +1,7 @@
+import type { AssembleContextResult } from "../project/context-assembly.js";
+export interface ContextCollectionResult {
+    signature_recorded: boolean;
+    proposal_created: boolean;
+    proposal_id?: string;
+}
+export declare function collectContextExperience(result: AssembleContextResult, network: string): ContextCollectionResult;

package/dist/loop-engineering/context-collect.js

@@ -0,0 +1,83 @@
+import { recordSignature } from "../experience/index.js";
+import { persistImprovementQueue } from "./improve.js";
+export function collectContextExperience(result, network) {
+    const objectTypes = extractObjectTypes(result.objects);
+    const hasEmbeddedHistory = !!result.embedded_history;
+    const hasEvents = !!result.events && result.events.length > 0;
+    const signature = {
+        intent: "assemble_context",
+        signals: {
+            object_types: objectTypes,
+            object_count: result.objects.length,
+            has_embedded_history: hasEmbeddedHistory,
+            has_events: hasEvents,
+            context_digest: result.context_digest,
+            network,
+        },
+        timestamp: Date.now(),
+        outcome: "success",
+    };
+    let signatureRecorded = false;
+    try {
+        recordSignature(signature);
+        signatureRecorded = true;
+    }
+    catch {
+    }
+    let proposal;
+    if (objectTypes.length >= 3) {
+        proposal = {
+            proposal_id: `PROP-CTX-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+            source_diagnosis_id: `CTX-${result.context_digest}`,
+            type: "description_rewrite",
+            priority: "P3",
+            automation: "semi",
+            apply_mode: "config_override",
+            override_category: "descriptions",
+            title: `Enrich assemble_context for ${objectTypes.join("+")} patterns`,
+            description: `Assembled context with ${objectTypes.length} object types (${objectTypes.join(", ")}). ` +
+                `Consider enriching the assemble_context action description to guide AI toward ` +
+                `common ${objectTypes.join("+")} business patterns.`,
+            target: "assemble_context",
+            proposed_change: {
+                action: "enrich_description",
+                object_types: objectTypes,
+                has_embedded_history: hasEmbeddedHistory,
+                has_events: hasEvents,
+                context_digest: result.context_digest,
+            },
+            evidence: {
+                context_digest: result.context_digest,
+                object_count: result.objects.length,
+                object_types: objectTypes,
+                network,
+            },
+            review_status: "pending",
+            ab_test_recommended: false,
+        };
+        try {
+            persistImprovementQueue([proposal]);
+        }
+        catch {
+        }
+    }
+    return {
+        signature_recorded: signatureRecorded,
+        proposal_created: !!proposal,
+        proposal_id: proposal?.proposal_id,
+    };
+}
+function extractObjectTypes(objects) {
+    const types = new Set();
+    for (const obj of objects) {
+        const data = obj?.data ?? obj;
+        const type = data?.type;
+        if (typeof type === "string") {
+            const match = type.match(/::(\w+)$/);
+            if (match) {
+                types.add(match[1]);
+            }
+        }
+    }
+    return Array.from(types);
+}

package/dist/loop-engineering/improve.d.ts

@@ -1,12 +1,15 @@
 import type { DiagnosisReport } from "./diagnose.js";
 export type ProposalType = "error_rule_addition" | "intent_rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation" | "industry_update_application";
 export type AutomationLevel = "full" | "semi" | "manual";
+export type ApplyMode = "config_override" | "source_patch";
 export interface ImprovementProposal {
     proposal_id: string;
     source_diagnosis_id: string;
     type: ProposalType;
     priority: string;
     automation: AutomationLevel;
+    apply_mode: ApplyMode;
+    override_category?: OverrideCategory;
     title: string;
     description: string;
     target: string;
@@ -14,7 +17,10 @@ export interface ImprovementProposal {
     evidence: Record<string, unknown>;
     review_status: "pending" | "approved" | "rejected" | "applied";
     ab_test_recommended: boolean;
+    persisted_at?: string;
+    reviewed_at?: string;
 }
+export type OverrideCategory = "risk-thresholds" | "descriptions" | "industry-profiles" | "scenario-defaults" | "recovery-priorities";
 export interface ImprovementReport {
     report_id: string;
     generated_date: string;
@@ -24,3 +30,26 @@ export interface ImprovementReport {
     summary: string;
 }
 export declare function generateImprovements(report: DiagnosisReport): ImprovementReport;
+export declare function persistImprovementQueue(proposals: ImprovementProposal[]): number;
+export interface QueueFilter {
+    status?: "pending" | "approved" | "rejected" | "applied";
+    type?: string;
+    priority?: string;
+}
+export declare function loadImprovementQueue(filter?: QueueFilter): ImprovementProposal[];
+export declare function updateProposalReviewStatus(proposalId: string, newStatus: "approved" | "rejected" | "applied"): ImprovementProposal | undefined;
+export declare function applyConfigOverride(proposal: ImprovementProposal): string;
+export declare function produceSourcePatch(proposal: ImprovementProposal): string;
+export interface FlywheelConfigSummary {
+    queue_path: string;
+    overrides_dir: string;
+    patches_dir: string;
+    total_proposals: number;
+    pending_count: number;
+    approved_count: number;
+    applied_count: number;
+    rejected_count: number;
+    override_files: string[];
+    recent_proposals: ImprovementProposal[];
+}
+export declare function getFlywheelConfigSummary(): FlywheelConfigSummary;

package/dist/loop-engineering/improve.js

@@ -1,4 +1,7 @@
 import { getPendingSuggestions } from "../knowledge/flywheel-loop.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
 function proposeErrorRuleAddition(diagnosis) {
     const evidence = diagnosis.evidence;
     const topMessages = evidence.top_error_messages || [];
@@ -20,6 +23,7 @@ function proposeErrorRuleAddition(diagnosis) {
         type: "error_rule_addition",
         priority: diagnosis.severity,
         automation: "semi",
+        apply_mode: "source_patch",
         title: `Add ERROR_RULES entries for ${diagnosis.target}`,
         description: `Generate new error classification rules to cover patterns currently falling into 'unknown'. AI should draft regex patterns; human reviewer validates accuracy and assigns correct error_code.`,
         target: "ERROR_RULES",
@@ -47,6 +51,8 @@ function proposeDescriptionRewrite(diagnosis) {
         type: "description_rewrite",
         priority: diagnosis.severity,
         automation: "semi",
+        apply_mode: "config_override",
+        override_category: "descriptions",
         title: `Rewrite description for ${evidence.tool_name || diagnosis.target}`,
         description: `The semantic layer produces no summary for ${((1 - (evidence.semantic_hit_rate || 0)) * 100).toFixed(1)}% of calls to this tool. AI should rewrite the tool description and INTENT_RULES to improve coverage. A/B test before merging.`,
         target: diagnosis.target,
@@ -73,6 +79,7 @@ function proposeSkillCreation(diagnosis) {
         type: "skill_creation",
         priority: diagnosis.severity,
         automation: "semi",
+        apply_mode: "source_patch",
         title: `Create new Skill for '${evidence.operation_type}' operations`,
         description: `This operation type has a ${(evidence.success_rate ? (1 - evidence.success_rate) * 100 : 0).toFixed(1)}% failure rate across ${evidence.total_calls} calls. A Skill with R1-R10 dialogue scripts, decision trees, and failure playbooks could guide users to success.`,
         target: `wowok-${evidence.operation_type}-guide`,
@@ -99,6 +106,8 @@ function proposeRecoveryAdjustment(diagnosis) {
         type: "recovery_priority_adjustment",
         priority: diagnosis.severity,
         automation: "semi",
+        apply_mode: "config_override",
+        override_category: "recovery-priorities",
         title: `Review recovery strategy for '${evidence.error_code}' errors`,
         description: `Error code '${evidence.error_code}' accounts for ${evidence.count} failures (${((evidence.percentage || 0) * 100).toFixed(1)}%). The current recovery strategy may need tuning — consider increasing max_attempts, adjusting automation level, or addressing the root cause.`,
         target: `RECOVERY_RULES['${evidence.error_code}']`,
@@ -124,6 +133,7 @@ function proposeInvestigation(diagnosis) {
         type: "investigation",
         priority: diagnosis.severity,
         automation: "manual",
+        apply_mode: "source_patch",
         title: diagnosis.title,
         description: `Manual investigation required. ${diagnosis.description}`,
         target: diagnosis.target,
@@ -162,6 +172,8 @@ function proposeIndustryUpdate(diagnosis) {
         type: "industry_update_application",
         priority: diagnosis.severity,
         automation: isHealthCritical ? "semi" : "manual",
+        apply_mode: "config_override",
+        override_category: "industry-profiles",
         title: `Apply ${pendingSuggestions.length} evolution suggestions for industry '${industry}'`,
         description: `Industry '${industry}' has health anomaly (health score ${evidence.health_score ?? "N/A"}, level ${evidence.health_level ?? "N/A"}). ` +
             `Has ${pendingSuggestions.length} pending evolution suggestions (${(evidence.high_priority_count ?? 0)} high priority). ` +
@@ -218,6 +230,11 @@ export function generateImprovements(report) {
     const summary = `${proposals.length} proposals generated from ${report.total_diagnoses} diagnoses. ` +
         `${p0Count} P0, ${semiCount} semi-automatic, ${abTestCount} recommend A/B testing. ` +
         `All proposals require human review before application.`;
+    try {
+        persistImprovementQueue(proposals);
+    }
+    catch {
+    }
     return {
         report_id: `IMPROVE-REPORT-${Date.now()}`,
         generated_date: new Date().toISOString(),
@@ -227,3 +244,164 @@ export function generateImprovements(report) {
         summary,
     };
 }
+function wowokRootDir() {
+    return process.env.WOWOK_CONFIG_DIR
+        ? process.env.WOWOK_CONFIG_DIR
+        : join(homedir(), ".wowok");
+}
+function improvementQueuePath() {
+    return join(wowokRootDir(), "improvement-queue.jsonl");
+}
+function overridesDir() {
+    return join(wowokRootDir(), "overrides");
+}
+function patchesDir() {
+    return join(wowokRootDir(), "patches");
+}
+export function persistImprovementQueue(proposals) {
+    if (proposals.length === 0)
+        return 0;
+    const queuePath = improvementQueuePath();
+    mkdirSync(dirname(queuePath), { recursive: true });
+    const now = new Date().toISOString();
+    const lines = proposals.map((p) => JSON.stringify({ ...p, persisted_at: now }));
+    appendFileSync(queuePath, lines.join("\n") + "\n", "utf-8");
+    return proposals.length;
+}
+export function loadImprovementQueue(filter) {
+    const queuePath = improvementQueuePath();
+    if (!existsSync(queuePath))
+        return [];
+    const raw = readFileSync(queuePath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    const proposals = [];
+    for (const line of lines) {
+        try {
+            const p = JSON.parse(line);
+            if (filter?.status && p.review_status !== filter.status)
+                continue;
+            if (filter?.type && p.type !== filter.type)
+                continue;
+            if (filter?.priority && p.priority !== filter.priority)
+                continue;
+            proposals.push(p);
+        }
+        catch {
+        }
+    }
+    return proposals;
+}
+export function updateProposalReviewStatus(proposalId, newStatus) {
+    const all = loadImprovementQueue();
+    let updated;
+    const now = new Date().toISOString();
+    for (const p of all) {
+        if (p.proposal_id === proposalId) {
+            p.review_status = newStatus;
+            p.reviewed_at = now;
+            updated = p;
+        }
+    }
+    if (!updated)
+        return undefined;
+    const queuePath = improvementQueuePath();
+    if (all.length === 0) {
+        writeFileSync(queuePath, "", "utf-8");
+    }
+    else {
+        const lines = all.map((p) => JSON.stringify(p));
+        writeFileSync(queuePath, lines.join("\n") + "\n", "utf-8");
+    }
+    return updated;
+}
+export function applyConfigOverride(proposal) {
+    if (proposal.apply_mode !== "config_override") {
+        throw new Error(`Proposal ${proposal.proposal_id} has apply_mode=${proposal.apply_mode}, not config_override`);
+    }
+    if (!proposal.override_category) {
+        throw new Error(`Proposal ${proposal.proposal_id} has no override_category`);
+    }
+    const dir = overridesDir();
+    mkdirSync(dir, { recursive: true });
+    const filePath = join(dir, `${proposal.override_category}.json`);
+    let existing = {};
+    if (existsSync(filePath)) {
+        try {
+            existing = JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const merged = { ...existing, ...proposal.proposed_change, _last_applied_proposal: proposal.proposal_id, _last_applied_at: new Date().toISOString() };
+    writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf-8");
+    return filePath;
+}
+export function produceSourcePatch(proposal) {
+    if (proposal.apply_mode !== "source_patch") {
+        throw new Error(`Proposal ${proposal.proposal_id} has apply_mode=${proposal.apply_mode}, not source_patch`);
+    }
+    const dir = patchesDir();
+    mkdirSync(dir, { recursive: true });
+    const baseName = `${proposal.proposal_id}.md`;
+    const filePath = join(dir, baseName);
+    const content = [
+        `# Source Patch Proposal: ${proposal.title}`,
+        "",
+        `- **Proposal ID**: ${proposal.proposal_id}`,
+        `- **Type**: ${proposal.type}`,
+        `- **Priority**: ${proposal.priority}`,
+        `- **Target**: ${proposal.target}`,
+        `- **Generated**: ${new Date().toISOString()}`,
+        "",
+        "## Description",
+        proposal.description,
+        "",
+        "## Proposed Change",
+        "```json",
+        JSON.stringify(proposal.proposed_change, null, 2),
+        "```",
+        "",
+        "## Evidence",
+        "```json",
+        JSON.stringify(proposal.evidence, null, 2),
+        "```",
+        "",
+        "## Application",
+        "This proposal requires manual review and merge into the MCP source code.",
+        "Do NOT auto-apply. After merging, republish the MCP server.",
+        "",
+        "## Override Whiteline (§4.4)",
+        "This proposal type is NOT in the config_override whitelist and must go",
+        "through source patch (risk rules, skill structure, schema fields).",
+    ].join("\n");
+    writeFileSync(filePath, content, "utf-8");
+    return filePath;
+}
+export function getFlywheelConfigSummary() {
+    const all = loadImprovementQueue();
+    const overrideFiles = [];
+    const oDir = overridesDir();
+    if (existsSync(oDir)) {
+        try {
+            for (const f of readdirSync(oDir)) {
+                if (f.endsWith(".json"))
+                    overrideFiles.push(f);
+            }
+        }
+        catch {
+        }
+    }
+    return {
+        queue_path: improvementQueuePath(),
+        overrides_dir: oDir,
+        patches_dir: patchesDir(),
+        total_proposals: all.length,
+        pending_count: all.filter((p) => p.review_status === "pending").length,
+        approved_count: all.filter((p) => p.review_status === "approved").length,
+        applied_count: all.filter((p) => p.review_status === "applied").length,
+        rejected_count: all.filter((p) => p.review_status === "rejected").length,
+        override_files: overrideFiles,
+        recent_proposals: all.slice(-5),
+    };
+}

package/dist/project/context-assembly.d.ts

@@ -0,0 +1,16 @@
+import type { z } from "zod";
+import type { ProjectOperationInputSchema } from "../schema/project/index.js";
+import { type ContextCollectionResult } from "../loop-engineering/context-collect.js";
+type ValidatedInput = z.infer<typeof ProjectOperationInputSchema>;
+export interface AssembleContextResult {
+    action: "assemble_context";
+    objects: unknown[];
+    events?: unknown[];
+    embedded_history?: Record<string, unknown>;
+    semantic_summary?: unknown;
+    context_digest: string;
+    next_action: string;
+    flywheel_collected?: ContextCollectionResult;
+}
+export declare function assembleContext(validated: ValidatedInput): Promise<AssembleContextResult>;
+export {};

package/dist/project/context-assembly.js

@@ -0,0 +1,130 @@
+import { createHash } from "crypto";
+import { query_objects, query_events } from "@wowok/wowok";
+import { buildDataSemantic } from "../schema/call/semantic.js";
+import { collectContextExperience } from "../loop-engineering/context-collect.js";
+const STATE_TRANSITION_EVENTS = [
+    "NewOrderEvent",
+    "ProgressEvent",
+    "ArbEvent",
+    "DemandPresentEvent",
+    "DemandFeedbackEvent",
+    "NewEntityEvent",
+];
+export async function assembleContext(validated) {
+    const contextObjects = validated.context_objects;
+    if (!contextObjects || contextObjects.length === 0) {
+        throw new Error("assemble_context requires 'context_objects' — an array of object IDs or LocalMark names.");
+    }
+    const network = (validated.context_network ?? "testnet");
+    const includeEvents = validated.include_events ?? false;
+    const objectsResult = await query_objects({
+        objects: contextObjects,
+        no_cache: false,
+        network,
+    });
+    const objects = objectsResult?.objects ?? [];
+    const embeddedHistory = extractEmbeddedHistory(objects);
+    const hasEmbeddedHistory = Object.keys(embeddedHistory).length > 0;
+    let events;
+    if (includeEvents) {
+        events = [];
+        for (const eventType of STATE_TRANSITION_EVENTS) {
+            try {
+                const eventResult = await query_events({
+                    type: eventType,
+                    limit: 5,
+                    order: "descending",
+                    network,
+                });
+                if (eventResult?.data && eventResult.data.length > 0) {
+                    events.push(...eventResult.data);
+                }
+            }
+            catch {
+            }
+        }
+        if (events.length === 0) {
+            events = undefined;
+        }
+    }
+    const semanticCtx = {
+        operation_type: "assemble_context",
+        data: { context_objects: objects, embedded_history: embeddedHistory, events },
+    };
+    const semanticSummary = buildDataSemantic({ objects, embedded_history: embeddedHistory, events }, semanticCtx);
+    const digestParts = objects.map((obj) => `${obj?.object ?? obj?.data?.object ?? "?"}:${obj?.version ?? obj?.data?.version ?? "?"}`);
+    digestParts.push(`ts:${Date.now()}`);
+    const contextDigest = createHash("sha256")
+        .update(digestParts.join("|"))
+        .digest("hex")
+        .substring(0, 16);
+    const nextAction = hasEmbeddedHistory
+        ? "Context assembled with embedded operation history. Use onchain_transaction with a specific digest to verify a past operation, or proceed with onchain_operations (consider dry_run=true first to validate)."
+        : events && events.length > 0
+            ? "Context assembled with recent events. Use onchain_transaction with a specific digest to verify any event's tx, or proceed with onchain_operations."
+            : "Context assembled (current state only). Proceed with onchain_operations (consider dry_run=true first to validate).";
+    let flywheelCollected;
+    try {
+        flywheelCollected = collectContextExperience({
+            action: "assemble_context",
+            objects,
+            events,
+            embedded_history: hasEmbeddedHistory ? embeddedHistory : undefined,
+            semantic_summary: semanticSummary,
+            context_digest: contextDigest,
+            next_action: nextAction,
+        }, network);
+    }
+    catch {
+    }
+    return {
+        action: "assemble_context",
+        objects,
+        events,
+        embedded_history: hasEmbeddedHistory ? embeddedHistory : undefined,
+        semantic_summary: semanticSummary,
+        context_digest: contextDigest,
+        next_action: nextAction,
+        flywheel_collected: flywheelCollected,
+    };
+}
+function extractEmbeddedHistory(objects) {
+    const history = {};
+    for (const obj of objects) {
+        const data = obj?.data ?? obj;
+        const objectId = obj?.object ?? data?.object;
+        if (!objectId)
+            continue;
+        const objectType = data?.type ?? "";
+        const extracted = {};
+        if (objectType.includes("Progress") && data?.session?.forwards) {
+            extracted.operation_history = data.session.forwards.map((f) => ({
+                operation: f.forward,
+                operator: f.who,
+                accomplished: f.accomplished,
+                time: f.time,
+                message: f.msg,
+            }));
+            extracted.next_node = data.session?.next_node;
+            extracted.threshold = data.session?.threshold;
+        }
+        if (objectType.includes("Order")) {
+            if (data?.dispute && Array.isArray(data.dispute) && data.dispute.length > 0) {
+                extracted.disputes = data.dispute;
+            }
+            if (data?.claimed_by) {
+                extracted.claimed_by = data.claimed_by;
+            }
+            if (data?.progress) {
+                extracted.progress_object = data.progress;
+            }
+        }
+        if (objectType.includes("Service") && data?.sales) {
+            extracted.sale_count = Array.isArray(data.sales) ? data.sales.length : 0;
+        }
+        if (Object.keys(extracted).length > 0) {
+            history[objectId] = extracted;
+        }
+    }
+    return history;
+}