@wowok/agent-mcp 2.6.3 → 2.6.4

package/dist/project/participation-radar.js

@@ -0,0 +1,428 @@
+import { LocalMark, query_objects, query_table, watch_conversations, } from "@wowok/wowok";
+import { analyzeOrderParticipation, aggregateRadar, isConsequenceNode, } from "../participation/radar-core.js";
+import { monitorOrder } from "../customer/order-monitor.js";
+import { analyzeMerchantInterest } from "../participation/merchant-interest.js";
+import { fetchMachineNodes } from "./machine-nodes.js";
+import { extractGenericTokenType, registryDisplayHint } from "../knowledge/fund-layer.js";
+const QUERY_BATCH = 50;
+function fld(obj, key) {
+    return (obj?.[key] ?? obj?.data?.[key]);
+}
+async function resolveAddress(nameOrAddress, what) {
+    const addr = await LocalMark.Instance().get_address(nameOrAddress);
+    if (!addr) {
+        throw new Error(`Cannot resolve ${what} '${nameOrAddress}' — not a valid address and no LocalMark entry found. ` +
+            `Register it via local_mark_operation or pass the 0x address directly.`);
+    }
+    return addr;
+}
+function balanceStr(v) {
+    if (v == null)
+        return undefined;
+    if (typeof v === "object" && "balance" in v)
+        return String(v.balance);
+    return String(v);
+}
+function balanceToken(v) {
+    if (v != null && typeof v === "object" && typeof v.token_type === "string") {
+        return v.token_type;
+    }
+    return undefined;
+}
+function summarizeAllocation(raw, account) {
+    const list = Array.isArray(raw)
+        ? raw
+        : Array.isArray(raw?.allocators)
+            ? raw.allocators
+            : [];
+    if (list.length === 0)
+        return undefined;
+    let recipient_slots = 0;
+    let guard_gated_slots = 0;
+    let direct_to_me_slots = 0;
+    let to_payer_slots = 0;
+    const me = account.toLowerCase();
+    for (const allocator of list) {
+        for (const s of allocator?.sharing ?? []) {
+            recipient_slots++;
+            const who = s?.who;
+            if (who == null)
+                continue;
+            if (typeof who === "object" && "GuardIdentifier" in who)
+                guard_gated_slots++;
+            else if (typeof who === "object" && "Signer" in who)
+                to_payer_slots++;
+            else if (typeof who === "object" && "Entity" in who) {
+                const entity = who.Entity;
+                const addr = typeof entity === "string" ? entity : entity?.name_or_address;
+                if (typeof addr === "string" && addr.toLowerCase() === me)
+                    direct_to_me_slots++;
+            }
+            else if (typeof who === "string" && who.toLowerCase() === me) {
+                direct_to_me_slots++;
+            }
+        }
+    }
+    return { recipient_slots, guard_gated_slots, direct_to_me_slots, to_payer_slots };
+}
+async function queryObjectsBatched(addresses, network) {
+    const out = [];
+    for (let i = 0; i < addresses.length; i += QUERY_BATCH) {
+        const batch = addresses.slice(i, i + QUERY_BATCH);
+        const res = await query_objects({ objects: batch, network });
+        out.push(...(res?.objects ?? []));
+    }
+    return out;
+}
+async function fetchEntityPermissions(permissionAddress, network) {
+    const map = new Map();
+    const fieldIds = [];
+    let cursor = undefined;
+    for (;;) {
+        const tableResult = await query_table({
+            parent: permissionAddress,
+            cursor: cursor ?? undefined,
+            network,
+        });
+        if (!tableResult?.items || tableResult.items.length === 0)
+            break;
+        for (const item of tableResult.items) {
+            if (item.object)
+                fieldIds.push(item.object);
+        }
+        if (!tableResult.hasNextPage || !tableResult.nextCursor)
+            break;
+        cursor = tableResult.nextCursor;
+    }
+    const items = (await queryObjectsBatched(fieldIds, network));
+    for (const item of items) {
+        if (item?.type !== "TableItem_PermissionPerm")
+            continue;
+        const entity = fld(item, "address");
+        const permRaw = fld(item, "perm") ?? [];
+        const indexes = permRaw
+            .map(p => (typeof p === "number" ? p : typeof p?.index === "number" ? p.index : null))
+            .filter((p) => p !== null);
+        if (entity)
+            map.set(entity, indexes);
+    }
+    return map;
+}
+function toRadarMachineNodes(raw) {
+    return raw.map(n => ({
+        name: n.name,
+        pairs: (Array.isArray(n.value) ? n.value : []).map(pair => ({
+            prev_node: pair.prev_node,
+            forwards: (pair.forwards ?? []).map(f => ({
+                name: f.name,
+                permissionIndex: f.permissionIndex ?? null,
+                namedOperator: f.namedOperator ?? null,
+                guard: f.guard?.guard ?? (typeof f.guard === "string" ? f.guard : null),
+                weight: f.weight ?? null,
+            })),
+        })),
+    }));
+}
+export async function handleParticipationRadar(v) {
+    if (!v.radar_account) {
+        throw new Error("'radar_account' is required for participation_radar");
+    }
+    if (!v.radar_targets || v.radar_targets.length === 0) {
+        throw new Error("'radar_targets' (1-20 in-flight orders) is required for participation_radar");
+    }
+    const network = (v.network ?? "testnet");
+    const includeAlerts = v.radar_include_alerts ?? true;
+    const gaps = [];
+    const account = await resolveAddress(v.radar_account, "radar_account");
+    const targets = await Promise.all(v.radar_targets.map(async (t) => ({
+        progress: await resolveAddress(t.progress, "progress"),
+        order: t.order ? await resolveAddress(t.order, "order") : undefined,
+    })));
+    const allAddrs = targets.flatMap(t => (t.order ? [t.progress, t.order] : [t.progress]));
+    const objects = await queryObjectsBatched(allAddrs, network);
+    const byAddress = new Map();
+    for (const o of objects) {
+        const addr = fld(o, "object");
+        if (addr)
+            byAddress.set(addr, o);
+    }
+    const progressObjs = new Map();
+    const orderObjs = new Map();
+    for (const t of targets) {
+        const p = byAddress.get(t.progress);
+        if (!p) {
+            gaps.push(`Progress ${t.progress} not found on ${network} — target skipped.`);
+            continue;
+        }
+        progressObjs.set(t.progress, p);
+        if (t.order) {
+            const o = byAddress.get(t.order);
+            if (o)
+                orderObjs.set(t.order, o);
+            else
+                gaps.push(`Order ${t.order} not found on ${network} — order-holder detection disabled for ${t.progress}.`);
+        }
+    }
+    if (targets.length > 0 && progressObjs.size === 0) {
+        gaps.push(`NETWORK MISMATCH SUSPECTED: 0/${targets.length} radar targets exist on network='${network}'. ` +
+            `These objects most likely live on a different network — re-run with the matching 'network' parameter.`);
+    }
+    const machineAddrs = [...new Set([...progressObjs.values()].map(p => fld(p, "machine")).filter((x) => !!x))];
+    const serviceAddrs = [...new Set([...orderObjs.values()].map(o => fld(o, "service")).filter((x) => !!x))];
+    const arbAddrs = [...new Set([...orderObjs.values()].flatMap(o => {
+            const d = fld(o, "dispute");
+            return Array.isArray(d) ? d : [];
+        }))];
+    const machineObjs = new Map();
+    const machineNodes = new Map();
+    const serviceObjs = new Map();
+    const arbObjs = new Map();
+    await Promise.all([
+        ...machineAddrs.map(async (addr) => {
+            try {
+                const [objArr, nodes] = await Promise.all([
+                    queryObjectsBatched([addr], network),
+                    fetchMachineNodes(addr, network),
+                ]);
+                if (objArr[0])
+                    machineObjs.set(addr, objArr[0]);
+                machineNodes.set(addr, toRadarMachineNodes(nodes));
+            }
+            catch (e) {
+                gaps.push(`Machine ${addr} fetch failed: ${e.message} — workflow unknown for its orders.`);
+            }
+        }),
+        (async () => {
+            if (serviceAddrs.length === 0)
+                return;
+            try {
+                const arr = await queryObjectsBatched(serviceAddrs, network);
+                for (const s of arr) {
+                    const addr = fld(s, "object");
+                    if (addr)
+                        serviceObjs.set(addr, s);
+                }
+            }
+            catch (e) {
+                gaps.push(`Service query failed: ${e.message} — compensation/reward context degraded.`);
+            }
+        })(),
+        (async () => {
+            if (arbAddrs.length === 0)
+                return;
+            try {
+                const arr = await queryObjectsBatched(arbAddrs, network);
+                for (const a of arr) {
+                    const addr = fld(a, "object");
+                    if (addr)
+                        arbObjs.set(addr, a);
+                }
+            }
+            catch (e) {
+                gaps.push(`Arb query failed: ${e.message} — compensation claim detection disabled.`);
+            }
+        })(),
+    ]);
+    const permissionByMachine = new Map();
+    const permAddrs = [...new Set(machineAddrs.map(a => fld(machineObjs.get(a), "permission")).filter((x) => !!x))];
+    const permData = new Map();
+    await Promise.all(permAddrs.map(async (addr) => {
+        try {
+            const [objArr, entityPermissions] = await Promise.all([
+                queryObjectsBatched([addr], network),
+                fetchEntityPermissions(addr, network),
+            ]);
+            const permObj = objArr[0];
+            permData.set(addr, {
+                address: addr,
+                entity_count: fld(permObj, "entity_count"),
+                perm_remark: fld(permObj, "perm_remark"),
+                entityPermissions,
+            });
+        }
+        catch (e) {
+            gaps.push(`Permission ${addr} fetch failed: ${e.message} — operator permission matching degraded.`);
+        }
+    }));
+    for (const mAddr of machineAddrs) {
+        const pAddr = fld(machineObjs.get(mAddr), "permission");
+        if (pAddr && permData.has(pAddr))
+            permissionByMachine.set(mAddr, permData.get(pAddr));
+    }
+    let unreadTotal = 0;
+    const unreadByPeer = new Map();
+    try {
+        const convos = await watch_conversations({
+            account,
+            unreadOnly: true,
+            previewMessageCount: 0,
+            skipAutoMarkViewed: true,
+        });
+        const list = Array.isArray(convos) ? convos : convos?.conversations ?? [];
+        for (const c of list) {
+            const peer = c?.peerAddress;
+            const n = typeof c?.unreadCount === "number" ? c.unreadCount : 0;
+            if (typeof peer === "string" && n > 0) {
+                unreadByPeer.set(peer.toLowerCase(), n);
+                unreadTotal += n;
+            }
+        }
+    }
+    catch {
+        gaps.push("Messenger unread unavailable (radar account is not a local messenger account, or messenger storage offline) " +
+            "— unread_messages_total reported as 0.");
+    }
+    const results = [];
+    const now = Date.now();
+    for (const t of targets) {
+        const progress = progressObjs.get(t.progress);
+        if (!progress)
+            continue;
+        const order = t.order ? orderObjs.get(t.order) : undefined;
+        const machineAddr = fld(progress, "machine");
+        const currentNode = fld(progress, "current") ?? "";
+        const namedOperators = fld(progress, "namedOperator") ?? [];
+        const namedAccounts = {};
+        for (const n of namedOperators) {
+            if (n?.name)
+                namedAccounts[n.name] = Array.isArray(n.operators) ? n.operators : [];
+        }
+        const serviceAddr = order ? fld(order, "service") : undefined;
+        const service = serviceAddr ? serviceObjs.get(serviceAddr) : undefined;
+        let pendingCompensation;
+        const builder = order ? fld(order, "builder") : undefined;
+        if (order && builder === account) {
+            const disputes = fld(order, "dispute") ?? [];
+            for (const arbAddr of disputes) {
+                const arb = arbObjs.get(arbAddr);
+                if (!arb)
+                    continue;
+                const indemnity = fld(arb, "indemnity");
+                if (indemnity) {
+                    pendingCompensation = {
+                        arbitration: fld(arb, "arbitration") ?? arbAddr,
+                        note: `Arbitration verdict recorded an indemnity (Arb ${arbAddr}). ` +
+                            `Claim via service op='compensation_claim' — paid directly from the Service compensation_fund. ` +
+                            `(Claimed-status is not readable from the Arb object; the contract rejects double-claims.)`,
+                    };
+                    break;
+                }
+            }
+        }
+        const claimableRewards = [];
+        if (service && builder === account) {
+            const rewards = fld(service, "rewards") ?? [];
+            for (const r of rewards) {
+                claimableRewards.push({
+                    address: r,
+                    description: `Service reward ${r} (guard-gated — eligibility verified at claim time)`,
+                });
+            }
+        }
+        const completed = isConsequenceNode(currentNode, "completed");
+        const refunded = isConsequenceNode(currentNode, "refunded");
+        let orderUnread = 0;
+        if (unreadByPeer.size > 0) {
+            const counterparties = new Set();
+            if (builder)
+                counterparties.add(builder.toLowerCase());
+            for (const ops of Object.values(namedAccounts)) {
+                for (const op of ops)
+                    counterparties.add(op.toLowerCase());
+            }
+            counterparties.delete(account.toLowerCase());
+            for (const peer of counterparties) {
+                orderUnread += unreadByPeer.get(peer) ?? 0;
+            }
+        }
+        const radarInput = {
+            account,
+            progress_address: t.progress,
+            order_address: t.order,
+            current_node: currentNode,
+            order_holder: builder,
+            machine_nodes: machineAddr ? machineNodes.get(machineAddr) : undefined,
+            permission: machineAddr ? permissionByMachine.get(machineAddr) ?? null : null,
+            named_accounts: namedAccounts,
+            claimable_rewards: claimableRewards.length > 0 ? claimableRewards : undefined,
+            pending_compensation: pendingCompensation,
+            rating_pending: completed && builder === account,
+            unread_messages: orderUnread > 0 ? orderUnread : undefined,
+            last_progress_at: fld(progress, "current_time") ?? undefined,
+            now,
+        };
+        const result = analyzeOrderParticipation(radarInput);
+        if (result.perspective === "operator") {
+            result.interest_analysis = analyzeMerchantInterest({
+                account,
+                current_node: currentNode,
+                operable: result.operable,
+                waiting_on: result.waiting_on,
+                order_amount: balanceStr(fld(order, "amount")),
+                token_type: balanceToken(fld(order, "amount")),
+                allocation: summarizeAllocation(fld(service, "order_allocators"), account),
+                compensation_fund: balanceStr(fld(service, "compensation_fund")),
+                arbitration_bound: (fld(service, "arbitrations") ?? []).length > 0,
+                rewards_count: (fld(service, "rewards") ?? []).length,
+                stalled_hours: radarInput.last_progress_at != null
+                    ? (now - radarInput.last_progress_at) / 3_600_000
+                    : undefined,
+                terminal: completed ? "completed" : refunded ? "refunded" : null,
+                unread_messages: orderUnread > 0 ? orderUnread : undefined,
+            });
+        }
+        if (includeAlerts && order) {
+            const snapshot = {
+                order_id: t.order,
+                service_id: serviceAddr ?? "",
+                current_node: currentNode || undefined,
+                created_at: Number(fld(order, "time") ?? now) || now,
+                last_progress_at: fld(progress, "current_time") ?? undefined,
+                now,
+                order_amount: (() => { try {
+                    return BigInt(fld(order, "amount") ?? 0);
+                }
+                catch {
+                    return undefined;
+                } })(),
+                compensation_balance: (() => { try {
+                    const c = fld(service, "compensation_fund");
+                    return c != null ? BigInt(c) : undefined;
+                }
+                catch {
+                    return undefined;
+                } })(),
+                token: registryDisplayHint(extractGenericTokenType(fld(service, "type_raw"))),
+                has_arbitration: (fld(service, "arbitrations") ?? []).length > 0,
+                pending_user_action: result.operable.some(f => f.execution_path === "order_holder"),
+                completed,
+                refunded,
+            };
+            try {
+                const alerts = monitorOrder({
+                    current: snapshot,
+                    thresholds: v.radar_monitor_thresholds,
+                });
+                if (alerts.length > 0) {
+                    result.attached_alerts = alerts;
+                }
+            }
+            catch (e) {
+                gaps.push(`Order monitor failed for ${t.order}: ${e.message}.`);
+            }
+        }
+        results.push(result);
+    }
+    const dashboard = aggregateRadar(results, unreadTotal);
+    return {
+        action: "participation_radar",
+        account,
+        orders_analyzed: dashboard.orders_analyzed,
+        actionable: dashboard.actionable,
+        waiting: dashboard.waiting,
+        all_pending_claims: dashboard.all_pending_claims,
+        unread_messages_total: dashboard.unread_messages_total,
+        data_gaps: gaps,
+        summary: dashboard.summary,
+    };
+}

package/dist/project/pipeline-actions.d.ts

@@ -0,0 +1,101 @@
+import type { ObjectPuzzleEntry } from "./business-puzzle.js";
+import type { SubstepRecord, SubstepEdge } from "./substep-trace.js";
+export interface AnalyzeIntentInput {
+    intent?: string;
+    project_description?: string;
+    project_name?: string;
+    target_objects?: string[];
+    project_industry?: string;
+    project?: string;
+    version?: string;
+}
+export declare function handleAnalyzeIntent(v: AnalyzeIntentInput): {
+    intent_parsed: import("./business-puzzle.js").IntentParsed;
+    puzzles: Record<string, ObjectPuzzleEntry>;
+    overall_completeness: "complete" | "partial" | "empty";
+    next_step: string;
+    recommended_creation_order: string[];
+    warnings: string[];
+    action: "analyze_intent";
+};
+export interface AggregateRisksInput {
+    project?: string;
+    version?: string;
+    project_industry?: string;
+    intent?: string;
+    project_description?: string;
+    project_name?: string;
+    puzzles?: Record<string, {
+        puzzle?: unknown;
+        completeness?: unknown;
+        missing_dimensions: string[];
+    }>;
+    severity_threshold?: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "INFO";
+    user_confirmed_high_risks?: string[];
+    planned_objects?: {
+        object_type: string;
+        is_new: boolean;
+        name?: string;
+    }[];
+    planned_operations?: {
+        object_type: string;
+        trigger: "create" | "publish";
+        name?: string;
+    }[];
+}
+export declare function handleAggregateRisks(v: AggregateRisksInput): {
+    intent_echo?: {
+        primary_object: string;
+        industry: string;
+        overall_completeness: "complete" | "partial" | "empty";
+    } | undefined;
+    safety_findings?: import("../knowledge/safety-rules.js").SafetyRiskItem[] | undefined;
+    namespace: {
+        prefix: string;
+        version: string;
+        industry?: import("./namespace.js").IndustryMode;
+    };
+    findings: import("./risk-aggregator.js").AggregatedRisk[];
+    severity_summary: Record<import("./risk-aggregator.js").RiskSeverity, number>;
+    status: "RISK_PASSED" | "RISK_BLOCKED" | "RISK_PENDING_CONFIRM" | "RISK_CANCELLED";
+    pending_confirmations?: Array<{
+        risk_rule_id: string;
+        description: string;
+        fix_suggestion: string;
+        object_type: import("./namespace.js").ProjectObjectType;
+        entry_id: string;
+    }>;
+    calibrated_at: number;
+    fix_suggestions_grouped?: Record<string, Array<{
+        risk_rule_id: string;
+        severity: import("./risk-aggregator.js").RiskSeverity;
+        message: string;
+        fix_suggestion: string;
+        entry_id: string;
+    }>>;
+    warnings: string[];
+    action: "aggregate_risks";
+};
+export interface TraceSubstepsInput {
+    project?: string;
+    version?: string;
+    network?: "testnet" | "mainnet";
+    substeps?: SubstepRecord[];
+    substep_edges?: SubstepEdge[];
+}
+export declare function handleTraceSubsteps(v: TraceSubstepsInput): {
+    namespace: {
+        prefix: string;
+        version: string;
+    };
+    network: import("./substep-trace.js").SubstepNetwork;
+    coherent: boolean;
+    dangling_inputs: import("./substep-trace.js").DanglingInput[];
+    circular_refs: import("./substep-trace.js").CircularRef[];
+    missing_outputs: import("./substep-trace.js").MissingOutput[];
+    cross_step_breaks: import("./substep-trace.js").CrossStepBreak[];
+    step_details: import("./substep-trace.js").StepTraceDetail[];
+    topological_order: string[];
+    d10_check: import("./substep-trace.js").D10CheckResult;
+    action: "trace_substeps";
+};

package/dist/project/pipeline-actions.js

@@ -0,0 +1,109 @@
+import { analyzeBusinessIntent } from "./business-puzzle.js";
+import { aggregateProjectRisks } from "./risk-aggregator.js";
+import { traceSubsteps } from "./substep-trace.js";
+import { updateStageCache } from "./index.js";
+import { checkObjectReuseRules, checkImmutabilityRules, } from "../knowledge/safety-rules.js";
+export function handleAnalyzeIntent(v) {
+    const user_intent = (v.intent ?? v.project_description ?? v.project_name ?? "").trim();
+    if (!user_intent) {
+        throw new Error("analyze_intent requires 'intent' (business description text). " +
+            "Example: intent='I want to open an online toy store with escrow and dispute resolution'.");
+    }
+    const result = analyzeBusinessIntent({
+        user_intent,
+        project_name: v.project_name,
+        target_objects: v.target_objects,
+        industry: v.project_industry,
+    });
+    const project_prefix = (v.project ?? "").trim();
+    if (project_prefix) {
+        updateStageCache(project_prefix, (v.version ?? "v1").trim(), {
+            stage: 2,
+            puzzles: result.puzzles,
+            business_intent: user_intent,
+            industry: result.intent_parsed.industry,
+        });
+    }
+    return { action: "analyze_intent", ...result };
+}
+export function handleAggregateRisks(v) {
+    const project_prefix = (v.project ?? "").trim();
+    if (!project_prefix) {
+        throw new Error("aggregate_risks requires 'project' (project prefix, e.g. 'myshop'). " +
+            "Use the same prefix as create_project so findings map to the project namespace.");
+    }
+    const version = (v.version ?? "v1").trim();
+    let puzzles;
+    let intent_echo;
+    if (v.puzzles) {
+        puzzles = Object.fromEntries(Object.entries(v.puzzles).map(([k, e]) => [
+            k,
+            { puzzle: e.puzzle, completeness: e.completeness, missing_dimensions: e.missing_dimensions },
+        ]));
+    }
+    else {
+        const user_intent = (v.intent ?? v.project_description ?? v.project_name ?? "").trim();
+        if (!user_intent) {
+            throw new Error("aggregate_risks requires 'puzzles' (from a prior analyze_intent result) " +
+                "OR 'intent' (business description — analyze_intent runs automatically first).");
+        }
+        const analyzed = analyzeBusinessIntent({
+            user_intent,
+            project_name: v.project_name,
+            industry: v.project_industry,
+        });
+        puzzles = analyzed.puzzles;
+        intent_echo = {
+            primary_object: analyzed.intent_parsed.primary_object,
+            industry: analyzed.intent_parsed.industry,
+            overall_completeness: analyzed.overall_completeness,
+        };
+    }
+    const result = aggregateProjectRisks({
+        project_prefix,
+        version,
+        industry: v.project_industry,
+        puzzles,
+        severity_threshold: v.severity_threshold,
+        user_confirmed_high_risks: v.user_confirmed_high_risks,
+    });
+    const safety_findings = [
+        ...(v.planned_objects ? checkObjectReuseRules(v.planned_objects) : []),
+        ...(v.planned_operations ? checkImmutabilityRules(v.planned_operations) : []),
+    ];
+    updateStageCache(project_prefix, version, {
+        stage: 3,
+        risk_status: result.status,
+        risk_can_proceed: result.status === "RISK_PASSED",
+    });
+    return {
+        action: "aggregate_risks",
+        ...result,
+        ...(safety_findings.length > 0 ? { safety_findings } : {}),
+        ...(intent_echo ? { intent_echo } : {}),
+    };
+}
+export function handleTraceSubsteps(v) {
+    const project_prefix = (v.project ?? "").trim();
+    if (!project_prefix) {
+        throw new Error("trace_substeps requires 'project' (project prefix, e.g. 'myshop').");
+    }
+    if (!v.substeps || v.substeps.length === 0) {
+        throw new Error("trace_substeps requires 'substeps' (non-empty array of substep execution records, " +
+            "63-spec §2.1). Construct them from your deployment execution trace: each onchain_operations " +
+            "call = one substep with step_id 'T<step>.<substep>', input_refs pointing at upstream substeps.");
+    }
+    const result = traceSubsteps({
+        project_prefix,
+        version: (v.version ?? "v1").trim(),
+        network: v.network ?? "testnet",
+        substeps: v.substeps,
+        edges: v.substep_edges,
+    });
+    updateStageCache(project_prefix, (v.version ?? "v1").trim(), {
+        stage: 5,
+        trace_coherent: result.coherent,
+        trace_can_proceed: result.coherent,
+    });
+    return { action: "trace_substeps", ...result };
+}