@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/knowledge/bridge-risk.js

@@ -0,0 +1,263 @@
+import { BRIDGE_MESSAGE_VERSION, BRIDGE_EVM_ADDRESS_LENGTH, BRIDGE_CURRENT_VERSION, } from "@wowok/wowok";
+const SUPPORTED_TOKENS = ["ETH", "WETH", "WBTC", "USDC", "USDT"];
+const MAX_IDEMPOTENCY_KEY_LENGTH = 128;
+const BRIDGE_ERROR_CODE_COUNT = 20;
+const R_B_01 = {
+    rule: {
+        id: "R-BRIDGE-01",
+        level: "CRITICAL",
+        category: "permission",
+        title: "Cross-chain asset security — committee signature verification is the single trust root",
+        description: "Bridge committee signatures are the only thing preventing forged cross-chain messages " +
+            "from minting tokens out of thin air (bridge.move:60). If a committee key is " +
+            "compromised, or if the verification logic has a bug, an attacker can claim arbitrary " +
+            "amounts of ETH/WETH/WBTC/USDC/USDT. The TransferLimiter caps single-transfer amounts " +
+            "but does not prevent repeated small attacks.",
+        affected_stakeholders: ["user", "committee", "system"],
+        scenario: "Committee private key leaks; attacker forges an approved transfer and claims funds",
+        mitigation: "Committee members MUST use HSM-backed multi-sig. Rotate keys on a schedule. Audit " +
+            "committee membership and signature verification logic on every release. Monitor " +
+            "limiter utilization for suspicious patterns. Have an EmergencyOp pause plan ready.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.assumes_committee_infallible)
+            return null;
+        return { ...R_B_01.rule, evidence: "assumes_committee_infallible=true (trust root is single-point)" };
+    },
+};
+const R_B_02 = {
+    rule: {
+        id: "R-BRIDGE-02",
+        level: "HIGH",
+        category: "cross_object",
+        title: "Bridge is mainnet-only — testnet operations will fail",
+        description: "The Bridge is only configured on mainnet. testnet nodes do not have the bridge " +
+            "role configured, so any cross-chain operation (cross_chain_wow_to_evm, " +
+            "cross_chain_evm_to_wow, claim_wow_to_evm, etc.) will abort. Developers who test on " +
+            "testnet will see EBridgeUnavailable (8) and may misdiagnose it as a code bug.",
+        affected_stakeholders: ["user", "operator"],
+        scenario: "Developer runs cross_chain_wow_to_evm on testnet; aborts with EBridgeUnavailable",
+        mitigation: "MCP layer MUST validate mainnet environment before submitting Bridge ops. Document " +
+            "the mainnet-only restriction prominently. For testing, use mainnet small-amount " +
+            "transactions or fork tests.",
+        related_move_error: "EBridgeUnavailable (8)",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.is_non_mainnet)
+            return null;
+        return { ...R_B_02.rule, evidence: "is_non_mainnet=true (Bridge unavailable)" };
+    },
+};
+const R_B_03 = {
+    rule: {
+        id: "R-BRIDGE-03",
+        level: "HIGH",
+        category: "structural",
+        title: "TransferLimiter caps single and cumulative transfer amounts — large transfers reject",
+        description: "The TransferLimiter (bridge.move:64) enforces both per-transfer and cumulative " +
+            "transfer caps per token type. A transfer that exceeds the cap aborts with " +
+            "ETokenAlreadyClaimedOrHitLimit (15) or similar. Users attempting large cross-chain " +
+            "moves will see their transactions rejected and may misdiagnose it as a bug.",
+        affected_stakeholders: ["user"],
+        scenario: "User attempts to bridge 1000 ETH; limiter rejects the transfer",
+        mitigation: "Document the limiter semantics. Before submitting, query the current limiter " +
+            "utilization. For large amounts, split into batches across multiple transactions " +
+            "and/or time windows. Surface the remaining cap in the UI.",
+        related_move_error: "ETokenAlreadyClaimedOrHitLimit (15)",
+        auto_fixable: false,
+    },
+    check: (ctx) => null,
+};
+const R_B_04 = {
+    rule: {
+        id: "R-BRIDGE-04",
+        level: "MEDIUM",
+        category: "permission",
+        title: "activeEvmAccount is a single global EVM account — key leak affects all assets",
+        description: "Bridge uses a single global activeEvmAccount that is auto-generated and transparent " +
+            "to users. All cross-chain EVM-side operations flow through this one account. If its " +
+            "private key leaks, every supported token (ETH/WETH/WBTC/USDC/USDT) on every " +
+            "supported chain is at risk. There is no per-user EVM account isolation.",
+        affected_stakeholders: ["user", "system"],
+        scenario: "activeEvmAccount private key leaks; attacker drains all bridged EVM assets",
+        mitigation: "Store the activeEvmAccount key in an HSM. Rotate the key on a schedule and via " +
+            "Versioned upgrade. Monitor EVM-side balances for anomalous outflows. Have an " +
+            "EmergencyOp pause plan ready.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.assumes_per_user_evm_account)
+            return null;
+        return { ...R_B_04.rule, evidence: "assumes_per_user_evm_account=true (it is global)" };
+    },
+};
+const R_B_05 = {
+    rule: {
+        id: "R-BRIDGE-05",
+        level: "MEDIUM",
+        category: "cross_object",
+        title: "Public EVM RPCs may rate-limit (HTTP 429) — cross-chain ops stall",
+        description: "Bridge ops that query EVM state (query_active_evm_account, query_supported_evm_chains, " +
+            "query_transfer_status, etc.) depend on an EVM RPC. Public RPCs (e.g. Infura free tier, " +
+            "Alchemy free tier) frequently return HTTP 429 under load. A 429 mid-flow stalls the " +
+            "cross-chain operation and may confuse the user. manage_evm_rpc supports multi-RPC " +
+            "rotation, but it must be configured in advance.",
+        affected_stakeholders: ["user", "operator"],
+        scenario: "User queries transfer status; public RPC returns 429; UI shows generic error",
+        mitigation: "Configure multiple EVM RPCs via manage_evm_rpc and enable failover. Use a paid RPC " +
+            "tier for production. Surface 429 as 'RPC busy, retry' rather than 'operation failed'.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.uses_public_evm_rpc)
+            return null;
+        return { ...R_B_05.rule, evidence: "uses_public_evm_rpc=true (429 risk)" };
+    },
+};
+const R_B_06 = {
+    rule: {
+        id: "R-BRIDGE-06",
+        level: "MEDIUM",
+        category: "lifecycle",
+        title: "EmergencyOp can pause the Bridge — assets lock during pause",
+        description: "EmergencyOp (bridge.move:89-91) can pause the entire Bridge. While paused, no " +
+            "cross-chain operations proceed — assets in flight cannot be claimed, new transfers " +
+            "cannot be initiated. The pause is intended for incident response, but a prolonged " +
+            "pause locks user funds for the duration.",
+        affected_stakeholders: ["user", "operator"],
+        scenario: "Bridge is paused for incident response; users cannot claim in-flight transfers",
+        mitigation: "Document the pause scenario and the emergency plan. Provide a status page showing " +
+            "pause state. Set expectations on pause duration and recovery. Operators should " +
+            "practice un-pause drills.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.is_paused)
+            return null;
+        return { ...R_B_06.rule, evidence: "is_paused=true (assets locked)" };
+    },
+};
+const R_B_07 = {
+    rule: {
+        id: "R-BRIDGE-07",
+        level: "LOW",
+        category: "structural",
+        title: `Only ${SUPPORTED_TOKENS.length} tokens supported — unsupported tokens cannot bridge`,
+        description: `Bridge supports exactly ${SUPPORTED_TOKENS.length} tokens: ${SUPPORTED_TOKENS.join(", ")}. ` +
+            `Any other token (e.g. DAI, LINK, custom tokens) cannot be bridged. Users holding ` +
+            `unsupported tokens will see their transfer rejected with EUnexpectedTokenType (3).`,
+        affected_stakeholders: ["user"],
+        scenario: "User attempts to bridge DAI; aborts with EUnexpectedTokenType",
+        mitigation: "Document the supported token list prominently. UI should filter the token picker to " +
+            "supported tokens only. For unsupported tokens, recommend an alternative bridge.",
+        related_move_error: "EUnexpectedTokenType (3)",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.unsupported_token)
+            return null;
+        return { ...R_B_07.rule, evidence: `unsupported_token=${ctx.unsupported_token} (supported: ${SUPPORTED_TOKENS.join(",")})` };
+    },
+};
+const R_B_08 = {
+    rule: {
+        id: "R-BRIDGE-08",
+        level: "MEDIUM",
+        category: "structural",
+        title: `Idempotency key max ${MAX_IDEMPOTENCY_KEY_LENGTH} chars — long keys truncate or reject`,
+        description: `BridgeIdempotencyKeySchema accepts strings of length 1-${MAX_IDEMPOTENCY_KEY_LENGTH}. ` +
+            `Callers who generate idempotency keys from long sources (e.g. full JSON payloads, ` +
+            `UUIDs with prefixes) may exceed the limit and see the operation rejected. The limit ` +
+            `exists to keep on-chain storage bounded.`,
+        affected_stakeholders: ["user"],
+        scenario: "Caller uses a 200-char idempotency key; operation rejected",
+        mitigation: "Generate idempotency keys from a hash (e.g. keccak256 of the payload, hex-encoded = " +
+            "66 chars) or a UUID (36 chars). Validate length client-side before submission.",
+        auto_fixable: true,
+    },
+    check: (ctx) => {
+        if (ctx.idempotency_key_length === undefined)
+            return null;
+        if (ctx.idempotency_key_length <= MAX_IDEMPOTENCY_KEY_LENGTH)
+            return null;
+        return { ...R_B_08.rule, evidence: `idempotency_key_length=${ctx.idempotency_key_length}, limit=${MAX_IDEMPOTENCY_KEY_LENGTH}` };
+    },
+};
+const R_B_09 = {
+    rule: {
+        id: "R-BRIDGE-09",
+        level: "LOW",
+        category: "structural",
+        title: `${BRIDGE_ERROR_CODE_COUNT} error codes — debugging requires a lookup table`,
+        description: `Bridge defines ${BRIDGE_ERROR_CODE_COUNT} error codes (EUnexpectedMessageType=0 ` +
+            `through ETokenValueIsZero=19). Debugging an abort requires mapping the numeric code ` +
+            `back to its name and meaning. New contributors often misread codes because they ` +
+            `are not enumerated in the abort message.`,
+        affected_stakeholders: ["user", "operator"],
+        scenario: "Bridge aborts with code 15; developer does not know what ETokenAlreadyClaimedOrHitLimit means",
+        mitigation: "Publish an error-code lookup table in the docs. SDK should decode abort codes into " +
+            "human-readable strings. MCP layer should surface the decoded name in error messages.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.expects_simple_error_codes)
+            return null;
+        return { ...R_B_09.rule, evidence: `expects_simple_error_codes=true (there are ${BRIDGE_ERROR_CODE_COUNT})` };
+    },
+};
+const R_B_10 = {
+    rule: {
+        id: "R-BRIDGE-10",
+        level: "MEDIUM",
+        category: "lifecycle",
+        title: `Versioned upgrade (current=${BRIDGE_CURRENT_VERSION}) can brick the Bridge if botched`,
+        description: `Bridge uses Versioned to wrap BridgeInner (bridge.move:49), supporting schema upgrades. ` +
+            `The current version is BRIDGE_CURRENT_VERSION=${BRIDGE_CURRENT_VERSION}. An upgrade ` +
+            `that mishandles the inner version migration can permanently brick the Bridge — ` +
+            `funds in flight would be locked, and recovery requires a new package version. The ` +
+            `message_version (current=${BRIDGE_MESSAGE_VERSION}) and EVM address length ` +
+            `(${BRIDGE_EVM_ADDRESS_LENGTH} bytes) are also versioned.`,
+        affected_stakeholders: ["user", "operator", "system"],
+        scenario: "Upgrade mishandles BridgeInner migration; Bridge becomes unusable",
+        mitigation: "Test upgrades on a fork with full state replay. Keep a rollback package version " +
+            "ready. Stage upgrades with a pause window so users can complete in-flight ops. " +
+            "Audit message_version and EVM address length compatibility on every upgrade.",
+        related_move_error: "EWrongInnerVersion (7)",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.versioned_upgrade_in_progress)
+            return null;
+        return { ...R_B_10.rule, evidence: `versioned_upgrade_in_progress=true (current=${BRIDGE_CURRENT_VERSION})` };
+    },
+};
+export const BRIDGE_RISK_RULES = [
+    R_B_01,
+    R_B_02,
+    R_B_03,
+    R_B_04,
+    R_B_05,
+    R_B_06,
+    R_B_07,
+    R_B_08,
+    R_B_09,
+    R_B_10,
+];
+export const BRIDGE_RISK_VERSION = "1.0.0";
+export function checkBridgeRisks(ctx) {
+    const risks = [];
+    for (const rule of BRIDGE_RISK_RULES) {
+        const r = rule.check(ctx);
+        if (r)
+            risks.push(r);
+    }
+    if (!risks.find(r => r.id === "R-BRIDGE-03")) {
+        risks.push(R_B_03.rule);
+    }
+    return risks;
+}
+export function getBridgeRiskById(id) {
+    return BRIDGE_RISK_RULES.find(r => r.rule.id === id)?.rule;
+}

package/dist/knowledge/contact-risk.d.ts

@@ -0,0 +1,32 @@
+export type ContactRiskLevel = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "INFO";
+export type ContactRiskCategory = "structural" | "semantic" | "lifecycle" | "permission" | "cross_object" | "knowledge";
+export type ContactStakeholder = "creator" | "im_member" | "consumer" | "system";
+export interface ContactRisk {
+    id: string;
+    level: ContactRiskLevel;
+    category: ContactRiskCategory;
+    title: string;
+    description: string;
+    affected_stakeholders: ContactStakeholder[];
+    scenario: string;
+    mitigation: string;
+    evidence?: string;
+    related_move_error?: string;
+    auto_fixable: boolean;
+}
+export interface ContactRiskCheckContext {
+    im_count?: number;
+    my_status_from_non_member?: boolean;
+    location_empty?: boolean;
+    im_add_description_uses_long_name?: boolean;
+    bound_to_permission_um?: boolean;
+    change_status_no_permission?: boolean;
+    constants_synced?: boolean;
+}
+export declare const CONTACT_RISK_RULES: {
+    rule: ContactRisk;
+    check: (ctx: ContactRiskCheckContext) => ContactRisk | null;
+}[];
+export declare const CONTACT_RISK_VERSION = "1.0.0";
+export declare function checkContactRisks(ctx: ContactRiskCheckContext): ContactRisk[];
+export declare function getContactRiskById(id: string): ContactRisk | undefined;

package/dist/knowledge/contact-risk.js

@@ -0,0 +1,200 @@
+import { MAX_IM_COUNT } from "@wowok/wowok";
+const R_C_01 = {
+    rule: {
+        id: "R-CONTACT-01",
+        level: "MEDIUM",
+        category: "permission",
+        title: "change_status has no permission check — IM list pollution risk",
+        description: "change_status lets any IM member self-update their status string without Permission " +
+            "verification (contact.move:32-43). If an attacker's address is added to the ims list " +
+            "(via im_add, which requires permission index 453), the attacker can freely pollute " +
+            "their status field (e.g. set status to 'fraud'). The risk is bounded by the im_add " +
+            "permission gate, but a misconfigured Permission could expose the IM list.",
+        affected_stakeholders: ["creator", "im_member"],
+        scenario: "Contact's IM list is misconfigured to allow public adds; attacker pollutes status",
+        mitigation: "Restrict permission index 453 (CONTACT_IM) to trusted guardians. Audit the IM list " +
+            "periodically. Business layer may validate status strings against an allowlist.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.change_status_no_permission)
+            return null;
+        return { ...R_C_01.rule, evidence: "change_status_no_permission=true" };
+    },
+};
+const R_C_02 = {
+    rule: {
+        id: "R-CONTACT-02",
+        level: "LOW",
+        category: "structural",
+        title: `MAX_IM_COUNT=${MAX_IM_COUNT} is permissive — on-chain storage cost`,
+        description: `A single Contact may hold up to MAX_IM_COUNT=${MAX_IM_COUNT} IM entries (contact.move:14). ` +
+            `Aborting with E_IM_COUNT_EXCEEDED (1) only triggers at the boundary. 200 entries is ` +
+            `relatively permissive for a social scenario; loading the full list on every read ` +
+            `increases gas and storage cost.`,
+        affected_stakeholders: ["creator"],
+        scenario: "Caller adds 200 IM entries to a single Contact",
+        mitigation: "Business layer should self-limit IM count well below 200. For high-volume contact " +
+            "lists, shard across multiple Contact objects and aggregate off-chain.",
+        related_move_error: "E_IM_COUNT_EXCEEDED (1)",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.im_count === undefined)
+            return null;
+        if (ctx.im_count < MAX_IM_COUNT)
+            return null;
+        return { ...R_C_02.rule, evidence: `im_count=${ctx.im_count}, limit=${MAX_IM_COUNT}` };
+    },
+};
+const R_C_03 = {
+    rule: {
+        id: "R-CONTACT-03",
+        level: "MEDIUM",
+        category: "semantic",
+        title: "IM list mutations emit no events — external indexers must poll",
+        description: "im_add / im_remove / im_clear do not emit events (contact.move:70-100). External " +
+            "indexers and notification systems cannot rely on event streams to track IM list " +
+            "changes; they must poll the ims field directly, increasing latency and RPC cost.",
+        affected_stakeholders: ["creator", "consumer"],
+        scenario: "Indexer expects an event on im_add but none is emitted; UI fails to refresh",
+        mitigation: "External indexers should poll the Contact.ims field on a cadence. A future version " +
+            "may add IMEvent; until then, do not build critical UX on IM event streams.",
+        auto_fixable: false,
+    },
+    check: (ctx) => null,
+};
+const R_C_04 = {
+    rule: {
+        id: "R-CONTACT-04",
+        level: "LOW",
+        category: "semantic",
+        title: "location defaults to empty string — may be misread as 'unset'",
+        description: "A freshly created Contact has location=\"\" (empty String). The Move type does not " +
+            "distinguish 'unset' from 'empty', so consumers may misinterpret an empty location " +
+            "as 'globally applicable' or as 'missing data'.",
+        affected_stakeholders: ["creator", "consumer"],
+        scenario: "Consumer reads location=\"\" and treats the Contact as global when it was never set",
+        mitigation: "Document that empty location means 'not specified'. If a default region is required, " +
+            "set location explicitly at creation time.",
+        auto_fixable: true,
+    },
+    check: (ctx) => {
+        if (!ctx.location_empty)
+            return null;
+        return { ...R_C_04.rule, evidence: "location=\"\" (empty, default)" };
+    },
+};
+const R_C_05 = {
+    rule: {
+        id: "R-CONTACT-05",
+        level: "MEDIUM",
+        category: "lifecycle",
+        title: "my_status silently fails for non-IM-members",
+        description: "my_status only updates the caller's status entry if the caller is in the ims list " +
+            "(contact.move:35-42). For a non-IM-member, the call silently succeeds without any " +
+            "state change — there is no abort and no event. Users get no feedback, making it " +
+            "impossible to distinguish 'status updated' from 'operation ignored'.",
+        affected_stakeholders: ["im_member"],
+        scenario: "Non-IM-member calls my_status expecting an error; operation is silently ignored",
+        mitigation: "SDK layer should pre-validate IM membership before submitting my_status and return a " +
+            "clear error. UI should show 'not an IM member' instead of 'success'.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.my_status_from_non_member)
+            return null;
+        return { ...R_C_05.rule, evidence: "my_status_from_non_member=true (will be silently ignored)" };
+    },
+};
+const R_C_06 = {
+    rule: {
+        id: "R-CONTACT-06",
+        level: "LOW",
+        category: "semantic",
+        title: "im_add description uses LONG_NAME (not DESCRIPTION) — different length cap",
+        description: "im_add's description parameter is validated with common::LONG_NAME rather than " +
+            "common::DESCRIPTION (contact.move:70-86). The two validators have different length " +
+            "limits; callers expecting DESCRIPTION semantics may submit overly long strings and " +
+            "hit an unexpected abort.",
+        affected_stakeholders: ["creator"],
+        scenario: "Caller submits an im_add description sized for DESCRIPTION but hits LONG_NAME limit",
+        mitigation: "Document that im_add description uses LONG_NAME validation. SDK should expose the " +
+            "exact limit so callers size their strings correctly.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.im_add_description_uses_long_name)
+            return null;
+        return { ...R_C_06.rule, evidence: "im_add description validated with LONG_NAME" };
+    },
+};
+const R_C_07 = {
+    rule: {
+        id: "R-CONTACT-07",
+        level: "MEDIUM",
+        category: "cross_object",
+        title: "permission_um_set creates Contact ↔ Permission bidirectional dependency",
+        description: "When Contact is set as a Permission's um via permission_um_set (contact.move:207-209), " +
+            "a bidirectional dependency forms: Permission.um → Contact, and Contact.permission → " +
+            "Permission. Deleting the Contact without first clearing the um reference leaves a " +
+            "dangling pointer in Permission.um.",
+        affected_stakeholders: ["creator", "consumer"],
+        scenario: "Contact is deleted while still bound as Permission.um; Permission.um becomes dangling",
+        mitigation: "Document the deletion order: (1) clear Permission.um via permission_um_set(null) " +
+            "first, (2) then delete the Contact. SDK should refuse to delete a Contact that is " +
+            "still bound as a um.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.bound_to_permission_um)
+            return null;
+        return { ...R_C_07.rule, evidence: "bound_to_permission_um=true (deletion requires unbinding)" };
+    },
+};
+const R_C_08 = {
+    rule: {
+        id: "R-CONTACT-08",
+        level: "LOW",
+        category: "knowledge",
+        title: "Knowledge layer & constant sync — RESOLVED",
+        description: `MAX_IM_COUNT is now synced to onchain-constants.ts (${MAX_IM_COUNT}). The MCP ` +
+            `Knowledge layer now includes contact-risk.ts. This risk rule is retained for ` +
+            `historical audit and to detect future regressions.`,
+        affected_stakeholders: ["system"],
+        scenario: "Future regression: someone removes MAX_IM_COUNT from onchain-constants.ts",
+        mitigation: "Run the onchain-constants sync test to detect drift.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (ctx.constants_synced)
+            return null;
+        return { ...R_C_08.rule, evidence: "constants_synced=false" };
+    },
+};
+export const CONTACT_RISK_RULES = [
+    R_C_01,
+    R_C_02,
+    R_C_03,
+    R_C_04,
+    R_C_05,
+    R_C_06,
+    R_C_07,
+    R_C_08,
+];
+export const CONTACT_RISK_VERSION = "1.0.0";
+export function checkContactRisks(ctx) {
+    const risks = [];
+    for (const rule of CONTACT_RISK_RULES) {
+        const r = rule.check(ctx);
+        if (r)
+            risks.push(r);
+    }
+    if (!risks.find(r => r.id === "R-CONTACT-03")) {
+        risks.push(R_C_03.rule);
+    }
+    return risks;
+}
+export function getContactRiskById(id) {
+    return CONTACT_RISK_RULES.find(r => r.rule.id === id)?.rule;
+}

package/dist/knowledge/demand-confirm.d.ts

@@ -0,0 +1,32 @@
+export type ConfirmSeverity = "block" | "warn" | "info";
+export interface DemandConfirmItem {
+    id: string;
+    severity: ConfirmSeverity;
+    title: string;
+    description: string;
+    passed: boolean;
+    evidence?: string;
+    fix_hint?: string;
+}
+export interface DemandCreationCheckInput {
+    description?: string;
+    location?: string;
+    rewards?: string[];
+    guards?: string[];
+    feedback?: string[];
+    service_identifier?: number | null;
+    by_guard?: string | null;
+    permission_set_available?: boolean;
+    namedNew?: {
+        name: string;
+        tag?: string;
+    } | null;
+}
+export declare function preCheckDemandCreation(input: DemandCreationCheckInput): DemandConfirmItem[];
+export declare function canCreateDemand(input: DemandCreationCheckInput): {
+    canCreate: boolean;
+    blockers: DemandConfirmItem[];
+    warnings: DemandConfirmItem[];
+    info: DemandConfirmItem[];
+};
+export declare function formatDemandCreationSummary(input: DemandCreationCheckInput): string;