@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/service-context.d.ts

@@ -0,0 +1,66 @@
+import { type ServiceScene, type ServicePermissionEntry, type ServiceCrossObjectBinding, type ServiceOrderFlowStage } from "./service-ledger.js";
+import { type ServiceTemplate } from "./service-templates.js";
+import { type SemanticToSchemaRule } from "./service-translation.js";
+import { type ServiceRiskRule, type ServiceRiskAssessment, type ServiceStakeholder } from "./service-risk.js";
+import { type ServicePuzzle, type ServicePuzzleCompleteness } from "./service-puzzle.js";
+import { type ServiceChecklistItem, type ServiceJsonForConfirm, type ServiceConfirmationQuestion } from "./service-confirm.js";
+export declare const SERVICE_CONTEXT_VERSION = "1.0.0";
+export type ServiceInjectionMode = "initial_design" | "mid_design_review" | "pre_publish" | "post_publish_modify" | "stakeholder_review" | "order_flow_check";
+export type ServiceStakeholderPerspective = ServiceStakeholder | "system";
+export interface ServiceContextBundle {
+    version: string;
+    mode: ServiceInjectionMode;
+    stakeholder_perspective?: ServiceStakeholderPerspective;
+    matched_scene?: ServiceScene;
+    matched_template?: ServiceTemplate;
+    matched_pattern?: SemanticToSchemaRule;
+    puzzle_state?: ServicePuzzle;
+    puzzle_completeness?: ServicePuzzleCompleteness;
+    relevant_risks: ServiceRiskRule[];
+    risk_assessment?: ServiceRiskAssessment;
+    relevant_checklist: ServiceChecklistItem[];
+    relevant_questions: ServiceConfirmationQuestion[];
+    relevant_builtin_permissions: ServicePermissionEntry[];
+    relevant_order_flow_stages: ServiceOrderFlowStage[];
+    cross_object_bindings: ServiceCrossObjectBinding[];
+    cross_object_refs: ServiceCrossObjectRef[];
+    onchain_constraints: ServiceOnchainConstraint[];
+    rendering_hints: ServiceRenderingHints;
+}
+export interface ServiceCrossObjectRef {
+    object: "Machine" | "Allocation" | "Arbitration" | "Repository" | "Reward" | "Treasury" | "Progress" | "Guard" | "Contact" | "Permission";
+    field: string;
+    scene_id: string;
+    description: string;
+    locked_after_publish: boolean;
+}
+export interface ServiceOnchainConstraint {
+    name: string;
+    value: string | number;
+    description: string;
+}
+export interface ServiceRenderingHints {
+    include_puzzle_template: boolean;
+    include_risk_details: boolean;
+    include_questions: boolean;
+    include_publish_warning: boolean;
+    include_transfer_warning: boolean;
+    include_order_flow_warning: boolean;
+    include_immutability_matrix: boolean;
+    max_length: number;
+}
+export interface BuildServiceContextInput {
+    mode: ServiceInjectionMode;
+    intent?: string;
+    service_json?: ServiceJsonForConfirm;
+    stakeholder?: ServiceStakeholderPerspective;
+    target_scene_id?: string;
+    target_permission_index?: number;
+    target_category?: ServiceScene["category"];
+    current_bPublished?: boolean;
+    current_bPaused?: boolean;
+    max_length?: number;
+}
+export declare function buildServiceContext(input: BuildServiceContextInput): ServiceContextBundle;
+export declare function buildPromptFromServiceContext(bundle: ServiceContextBundle): string;
+export declare function getServiceContextSummary(bundle: ServiceContextBundle): string;

package/dist/knowledge/service-context.js

@@ -0,0 +1,403 @@
+import { MAX_SALE_COUNT, MAX_REPOSITORY_COUNT, MAX_ARBITRATION_COUNT, MAX_DISCOUNT_COUNT_ONCE, MAX_DISCOUNT_TOTAL_COUNT, MAX_WIP_LENGTH, MAX_WIP_HASH_LENGTH, DEFAULT_LOCK_DURATION, } from "@wowok/wowok";
+import { findSceneById, inferSceneFromIntent, getScenesByCategory, isServicePermission, SERVICE_PERMISSIONS, SERVICE_ORDER_FLOW_STAGES, SERVICE_CROSS_OBJECT_BINDINGS, } from "./service-ledger.js";
+import { getServiceTemplatesByScene, } from "./service-templates.js";
+import { matchSemanticPattern, } from "./service-translation.js";
+import { getAllServiceRiskRules, assessServiceRisks, } from "./service-risk.js";
+import { initPuzzleFromIntent, checkPuzzleCompleteness, } from "./service-puzzle.js";
+import { SERVICE_PUBLISH_CHECKLIST, SERVICE_CONFIRMATION_QUESTIONS, } from "./service-confirm.js";
+export const SERVICE_CONTEXT_VERSION = "1.0.0";
+export function buildServiceContext(input) {
+    const max_length = input.max_length ?? 6000;
+    let matched_scene;
+    if (input.intent) {
+        matched_scene = inferSceneFromIntent(input.intent);
+    }
+    if (!matched_scene && input.target_scene_id) {
+        matched_scene = findSceneById(input.target_scene_id);
+    }
+    if (!matched_scene && input.target_category) {
+        const scenes = getScenesByCategory(input.target_category);
+        if (scenes.length > 0)
+            matched_scene = scenes[0];
+    }
+    if (!matched_scene && input.target_permission_index !== undefined && isServicePermission(input.target_permission_index)) {
+        matched_scene = findSceneById("service_retail");
+    }
+    let matched_template;
+    if (matched_scene) {
+        const templates = getServiceTemplatesByScene(matched_scene.id);
+        if (templates.length > 0)
+            matched_template = templates[0];
+    }
+    let matched_pattern;
+    if (input.intent) {
+        const patterns = matchSemanticPattern(input.intent);
+        if (patterns.length > 0)
+            matched_pattern = patterns[0];
+    }
+    let puzzle_state;
+    let puzzle_completeness;
+    if (input.mode === "initial_design" && input.intent) {
+        puzzle_state = initPuzzleFromIntent({ primary_goal: input.intent });
+        puzzle_completeness = checkPuzzleCompleteness(puzzle_state);
+    }
+    const relevant_risks = filterRiskRules(input.mode, input.stakeholder, matched_scene);
+    let risk_assessment;
+    if ((input.mode === "pre_publish" || input.mode === "post_publish_modify" || input.mode === "order_flow_check") && input.service_json) {
+        const ctx = {
+            object: input.service_json.object,
+            description: input.service_json.description,
+            location: input.service_json.location,
+            sales: input.service_json.sales,
+            repositories: input.service_json.repositories,
+            rewards: input.service_json.rewards,
+            arbitrations: input.service_json.arbitrations,
+            machine: input.service_json.machine,
+            discount: input.service_json.discount,
+            customer_required: input.service_json.customer_required,
+            order_allocators: input.service_json.order_allocators,
+            buy_guard: input.service_json.buy_guard,
+            compensation_fund_add: input.service_json.compensation_fund_add,
+            setting_locked_time_add: input.service_json.setting_locked_time_add,
+            compensation_fund_receive: input.service_json.compensation_fund_receive,
+            owner_receive: input.service_json.owner_receive,
+            pause: input.service_json.pause,
+            publish: input.service_json.publish,
+            um: input.service_json.um,
+            order_new: input.service_json.order_new,
+            current_bPublished: input.current_bPublished,
+            current_bPaused: input.current_bPaused,
+            current_machine_bound: input.current_bPublished,
+        };
+        risk_assessment = assessServiceRisks(ctx);
+    }
+    const relevant_checklist = filterChecklist(input.mode);
+    const relevant_questions = filterQuestions(input.mode);
+    const relevant_builtin_permissions = matched_scene
+        ? matched_scene.builtin_indexes
+        : [...SERVICE_PERMISSIONS];
+    const relevant_order_flow_stages = input.mode === "order_flow_check"
+        ? [...SERVICE_ORDER_FLOW_STAGES]
+        : [];
+    const cross_object_bindings = [...SERVICE_CROSS_OBJECT_BINDINGS];
+    const cross_object_refs = buildCrossObjectRefs(matched_scene);
+    const onchain_constraints = buildOnchainConstraints();
+    const rendering_hints = buildRenderingHints(input.mode, max_length, !!input.service_json?.publish, !!input.service_json?.builder, !!input.service_json?.order_new, input.current_bPublished ?? false);
+    return {
+        version: SERVICE_CONTEXT_VERSION,
+        mode: input.mode,
+        stakeholder_perspective: input.stakeholder,
+        matched_scene,
+        matched_template,
+        matched_pattern,
+        puzzle_state,
+        puzzle_completeness,
+        relevant_risks,
+        risk_assessment,
+        relevant_checklist,
+        relevant_questions,
+        relevant_builtin_permissions,
+        relevant_order_flow_stages,
+        cross_object_bindings,
+        cross_object_refs,
+        onchain_constraints,
+        rendering_hints,
+    };
+}
+function filterRiskRules(mode, stakeholder, scene) {
+    let rules = getAllServiceRiskRules();
+    if (mode === "initial_design") {
+        return rules.filter(r => r.category === "structural" || r.category === "authority");
+    }
+    if (mode === "pre_publish") {
+        return rules;
+    }
+    if (mode === "post_publish_modify") {
+        return rules.filter(r => r.category === "lifecycle" || r.category === "cross_object");
+    }
+    if (mode === "order_flow_check") {
+        return rules.filter(r => r.category === "semantic" || r.id.startsWith("R-S-2"));
+    }
+    if (mode === "stakeholder_review" && stakeholder) {
+        if (stakeholder === "owner") {
+            return rules.filter(r => r.category === "authority" || r.category === "lifecycle");
+        }
+        if (stakeholder === "customer") {
+            return rules.filter(r => r.category === "semantic" || r.id.startsWith("R-S-2"));
+        }
+        if (stakeholder === "provider") {
+            return rules.filter(r => r.category === "cross_object" || r.id.startsWith("R-S-5-01"));
+        }
+        if (stakeholder === "arbitrator") {
+            return rules.filter(r => r.id.startsWith("R-S-5-02") || r.id.startsWith("R-S-2-02"));
+        }
+        if (stakeholder === "system") {
+            return rules.filter(r => r.category === "lifecycle");
+        }
+    }
+    return rules;
+}
+function filterChecklist(mode) {
+    if (mode === "initial_design") {
+        return SERVICE_PUBLISH_CHECKLIST.filter(i => ["C-S-01", "C-S-02", "C-S-03", "C-S-04", "C-S-05", "C-S-06", "C-S-07"].includes(i.id));
+    }
+    if (mode === "pre_publish") {
+        return SERVICE_PUBLISH_CHECKLIST;
+    }
+    if (mode === "post_publish_modify") {
+        return SERVICE_PUBLISH_CHECKLIST.filter(i => ["C-S-12", "C-S-13", "C-S-14", "C-S-15", "C-S-16"].includes(i.id));
+    }
+    if (mode === "order_flow_check") {
+        return SERVICE_PUBLISH_CHECKLIST.filter(i => ["C-S-07"].includes(i.id));
+    }
+    return SERVICE_PUBLISH_CHECKLIST;
+}
+function filterQuestions(mode) {
+    if (mode === "pre_publish") {
+        return SERVICE_CONFIRMATION_QUESTIONS;
+    }
+    if (mode === "post_publish_modify") {
+        return SERVICE_CONFIRMATION_QUESTIONS.filter(q => !["QS1", "QS2", "QS5"].includes(q.id));
+    }
+    if (mode === "order_flow_check") {
+        return SERVICE_CONFIRMATION_QUESTIONS.filter(q => q.id === "QS9");
+    }
+    return [];
+}
+function buildCrossObjectRefs(scene) {
+    return [
+        {
+            object: "Machine",
+            field: "machine",
+            scene_id: "service_workflow",
+            description: "Machine workflow template — post-publish immutable. Progress inherits this binding.",
+            locked_after_publish: true,
+        },
+        {
+            object: "Allocation",
+            field: "order_allocators",
+            scene_id: "service_order_allocator",
+            description: "Fund distribution strategy — publish prerequisite, post-publish immutable.",
+            locked_after_publish: true,
+        },
+        {
+            object: "Arbitration",
+            field: "arbitrations",
+            scene_id: "service_arbitration",
+            description: "Dispute handlers — required when compensation_fund > 0, post-publish immutable.",
+            locked_after_publish: true,
+        },
+        {
+            object: "Repository",
+            field: "repositories",
+            scene_id: "service_retail",
+            description: "Shared data stores — mutable post-publish.",
+            locked_after_publish: false,
+        },
+        {
+            object: "Reward",
+            field: "rewards",
+            scene_id: "service_reward",
+            description: "Marketing incentives — mutable but locked by setting_lock_duration.",
+            locked_after_publish: false,
+        },
+        {
+            object: "Guard",
+            field: "buy_guard",
+            scene_id: "service_buy_guard",
+            description: "Buyer eligibility Guard — UNUSUAL: still mutable post-publish.",
+            locked_after_publish: false,
+        },
+        {
+            object: "Contact",
+            field: "um",
+            scene_id: "service_retail",
+            description: "User Manager (Contact object) — mutable post-publish.",
+            locked_after_publish: false,
+        },
+        {
+            object: "Treasury",
+            field: "(indirect via order_allocators.sharing.who=Entity)",
+            scene_id: "service_multi_allocator",
+            description: "Treasury referenced by Allocation.sharing.who=Entity (Treasury address). Not directly bound to Service.",
+            locked_after_publish: false,
+        },
+        {
+            object: "Progress",
+            field: "(created at order time)",
+            scene_id: "service_workflow",
+            description: "Progress object created per order (Stage 6 of buy flow). Inherits Machine from Service.",
+            locked_after_publish: false,
+        },
+        {
+            object: "Permission",
+            field: "permission",
+            scene_id: "service_retail",
+            description: "Permission object governing 21 SERVICE_* indexes (300-320). Bound at Service creation, immutable.",
+            locked_after_publish: true,
+        },
+    ];
+}
+function buildOnchainConstraints() {
+    return [
+        { name: "MAX_SALE_COUNT", value: MAX_SALE_COUNT, description: "Maximum sales items per Service" },
+        { name: "MAX_REPOSITORY_COUNT", value: MAX_REPOSITORY_COUNT, description: "Maximum repositories per Service" },
+        { name: "MAX_ARBITRATION_COUNT", value: MAX_ARBITRATION_COUNT, description: "Maximum arbitrations per Service" },
+        { name: "MAX_REWARD_COUNT", value: 20, description: "Maximum rewards per Service" },
+        { name: "MAX_DISCOUNT_COUNT_ONCE", value: MAX_DISCOUNT_COUNT_ONCE, description: "Maximum discount coupons per issue call" },
+        { name: "MAX_DISCOUNT_TOTAL_COUNT", value: MAX_DISCOUNT_TOTAL_COUNT, description: "Maximum total discount coupons per Service" },
+        { name: "MAX_WIP_LENGTH", value: MAX_WIP_LENGTH, description: "Maximum WIP URL length" },
+        { name: "MAX_WIP_HASH_LENGTH", value: MAX_WIP_HASH_LENGTH, description: "Maximum WIP hash length (sha256 hex)" },
+        { name: "DEFAULT_LOCK_DURATION", value: DEFAULT_LOCK_DURATION, description: "Default setting_lock_duration (30 days in ms)" },
+    ];
+}
+function buildRenderingHints(mode, max_length, hasPublish, hasTransfer, hasOrder, isPublished) {
+    return {
+        include_puzzle_template: mode === "initial_design",
+        include_risk_details: mode === "pre_publish" || mode === "stakeholder_review" || mode === "order_flow_check",
+        include_questions: mode === "pre_publish" || mode === "order_flow_check",
+        include_publish_warning: hasPublish,
+        include_transfer_warning: hasTransfer,
+        include_order_flow_warning: hasOrder,
+        include_immutability_matrix: mode === "post_publish_modify" || mode === "pre_publish" || isPublished,
+        max_length,
+    };
+}
+export function buildPromptFromServiceContext(bundle) {
+    const lines = [];
+    const h = bundle.rendering_hints;
+    lines.push(`═══ Service Context (mode: ${bundle.mode}) ═══`);
+    lines.push("");
+    if (bundle.matched_scene) {
+        lines.push(`Scene: ${bundle.matched_scene.name}`);
+        lines.push(`Category: ${bundle.matched_scene.category}`);
+        lines.push(`Permission range: ${bundle.matched_scene.permission_index_range}`);
+        lines.push("");
+    }
+    if (bundle.matched_template) {
+        lines.push(`Suggested template: ${bundle.matched_template.id} — ${bundle.matched_template.name}`);
+        if (bundle.matched_template.notes && bundle.matched_template.notes.length > 0) {
+            lines.push("Notes:");
+            for (const note of bundle.matched_template.notes.slice(0, 3)) {
+                lines.push(`  - ${note}`);
+            }
+        }
+        lines.push("");
+    }
+    if (h.include_puzzle_template && bundle.puzzle_completeness) {
+        const c = bundle.puzzle_completeness;
+        lines.push("─ Puzzle Completeness ──────────────");
+        lines.push(`Complete: ${c.complete ? "YES" : "NO"}`);
+        if (c.missing.length > 0) {
+            lines.push(`Missing dimensions: ${c.missing.join(", ")}`);
+            for (const md of c.missing_details.slice(0, 3)) {
+                lines.push(`  - ${md.dimension}: ${md.reason}`);
+            }
+        }
+        lines.push(`Next: ${c.next_step}`);
+        lines.push("");
+    }
+    if (h.include_risk_details && bundle.relevant_risks.length > 0) {
+        lines.push(`─ Relevant Risk Rules (${bundle.relevant_risks.length}) ──────────────`);
+        for (const r of bundle.relevant_risks.slice(0, 8)) {
+            lines.push(`  ${r.id} [${r.category}] — ${r.trigger}`);
+        }
+        if (bundle.relevant_risks.length > 8) {
+            lines.push(`  ... and ${bundle.relevant_risks.length - 8} more`);
+        }
+        lines.push("");
+    }
+    if (bundle.risk_assessment) {
+        lines.push("─ Risk Assessment ──────────────");
+        lines.push(`Overall: ${bundle.risk_assessment.overall_risk}`);
+        lines.push(`Detected: ${bundle.risk_assessment.risks.length} risk(s)`);
+        if (bundle.risk_assessment.risks.length > 0) {
+            for (const r of bundle.risk_assessment.risks.slice(0, 5)) {
+                lines.push(`  [${r.level}] ${r.id}: ${r.title}`);
+            }
+        }
+        lines.push("");
+    }
+    if (bundle.relevant_builtin_permissions.length > 0) {
+        lines.push(`─ Builtin Permissions (${bundle.relevant_builtin_permissions.length}) ──────────────`);
+        for (const p of bundle.relevant_builtin_permissions.slice(0, 10)) {
+            const mut = p.post_publish_mutability === "immutable" ? " [IMMUTABLE]"
+                : p.post_publish_mutability === "one_shot" ? " [ONE-SHOT]"
+                    : p.post_publish_mutability === "locked_by_duration" ? " [LOCKED]"
+                        : "";
+            lines.push(`  [${p.index}] ${p.name}: ${p.description}${mut}`);
+        }
+        if (bundle.relevant_builtin_permissions.length > 10) {
+            lines.push(`  ... and ${bundle.relevant_builtin_permissions.length - 10} more`);
+        }
+        lines.push("");
+    }
+    if (bundle.relevant_order_flow_stages.length > 0) {
+        lines.push("─ 8-Stage Order Flow ──────────────");
+        for (const stage of bundle.relevant_order_flow_stages) {
+            lines.push(`  Stage ${stage.stage}: ${stage.name} ${stage.always_executed ? "(always)" : "(conditional)"}`);
+            if (stage.side_effects.length > 0) {
+                lines.push(`    Side effects: ${stage.side_effects[0]}`);
+            }
+        }
+        lines.push("");
+    }
+    if (h.include_publish_warning) {
+        lines.push("⚠️ PUBLISH OPERATION DETECTED — IRREVERSIBLE");
+        lines.push("  Once published: machine/arbitrations/order_allocators become PERMANENTLY immutable");
+        lines.push("  bPublished cannot be reset to false — clone Service to 'reset'");
+        lines.push("");
+    }
+    if (h.include_transfer_warning) {
+        lines.push("⚠️ TRANSFER OPERATION DETECTED — IRREVERSIBLE");
+        lines.push("  Original owner loses ALL control. New owner inherits everything.");
+        lines.push("");
+    }
+    if (h.include_order_flow_warning) {
+        lines.push("⚠️ ORDER FLOW — 8 STAGES, stock deducted at quote (Stage 3)");
+        lines.push("  If Stages 4-7 fail, stock remains deducted (not rolled back)");
+        lines.push("");
+    }
+    if (h.include_immutability_matrix && bundle.cross_object_bindings.length > 0) {
+        lines.push("─ Post-publish Immutability Matrix ──────────────");
+        for (const b of bundle.cross_object_bindings) {
+            const status = b.locked_after_publish ? "🔒 IMMUTABLE" : "🔓 mutable";
+            lines.push(`  ${b.object} (${b.field}): ${status}`);
+        }
+        lines.push("");
+    }
+    if (bundle.onchain_constraints.length > 0) {
+        lines.push("─ On-chain Constraints ──────────────");
+        for (const c of bundle.onchain_constraints) {
+            lines.push(`  ${c.name} = ${c.value} — ${c.description}`);
+        }
+        lines.push("");
+    }
+    if (bundle.cross_object_refs.length > 0) {
+        lines.push(`─ Cross-object References (${bundle.cross_object_refs.length}) ──────────────`);
+        for (const ref of bundle.cross_object_refs.slice(0, 6)) {
+            const lock = ref.locked_after_publish ? " [locked]" : "";
+            lines.push(`  ${ref.object} (${ref.field})${lock}: ${ref.description}`);
+        }
+        if (bundle.cross_object_refs.length > 6) {
+            lines.push(`  ... and ${bundle.cross_object_refs.length - 6} more`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function getServiceContextSummary(bundle) {
+    const parts = [
+        `mode=${bundle.mode}`,
+        `scene=${bundle.matched_scene?.id ?? "none"}`,
+        `risks=${bundle.relevant_risks.length}`,
+        `permissions=${bundle.relevant_builtin_permissions.length}`,
+    ];
+    if (bundle.risk_assessment)
+        parts.push(`overall_risk=${bundle.risk_assessment.overall_risk}`);
+    if (bundle.matched_template)
+        parts.push(`template=${bundle.matched_template.id}`);
+    if (bundle.relevant_order_flow_stages.length > 0)
+        parts.push(`order_flow=8-stages`);
+    return parts.join(", ");
+}

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

@@ -0,0 +1,71 @@
+export interface ServiceScene {
+    id: string;
+    name: string;
+    category: "retail" | "rental" | "subscription" | "workflow" | "arbitration" | "compensation_fund" | "reward" | "dynamic_pricing" | "multi_allocator" | "buy_guard" | "order_allocator" | "general";
+    permission_index_range: string;
+    builtin_indexes: ServicePermissionEntry[];
+    cross_object_bindings: ServiceCrossObjectBinding[];
+    order_flow_stages: ServiceOrderFlowStage[];
+    owner_operations: string[];
+    admin_operations: string[];
+    permission_index_operations: string[];
+    mutable_after_publish: {
+        machine: boolean;
+        arbitrations: boolean;
+        order_allocators: boolean;
+        buy_guard: boolean;
+        rewards: "mutable" | "locked_by_duration";
+        compensation_fund_withdraw: "mutable" | "locked_by_duration";
+        compensation_fund_receive: "mutable" | "locked_by_duration";
+        sales: boolean;
+        description: boolean;
+        location: boolean;
+        repositories: boolean;
+        customer_required: boolean;
+        discount: boolean;
+        um: boolean;
+        pause: boolean;
+    };
+    publish_prerequisites: string[];
+    common_patterns: string[];
+    recommended_templates: string[];
+}
+export interface ServicePermissionEntry {
+    index: number;
+    name: string;
+    description: string;
+    governed_operation: string;
+    post_publish_mutability: "mutable" | "immutable" | "one_shot" | "locked_by_duration" | "na";
+}
+export interface ServiceCrossObjectBinding {
+    object: "Machine" | "Allocation" | "Arbitration" | "Repository" | "Reward" | "Guard" | "Treasury" | "Contact" | "Progress";
+    field: string;
+    required: boolean;
+    locked_after_publish: boolean;
+    notes: string;
+}
+export interface ServiceOrderFlowStage {
+    stage: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+    name: "pre_check" | "wip_verify" | "quote" | "create_order" | "create_allocation" | "create_progress" | "post_actions" | "return_result";
+    preconditions: string[];
+    side_effects: string[];
+    always_executed: boolean;
+}
+export declare const SERVICE_PERMISSIONS: ServicePermissionEntry[];
+export declare const SERVICE_ORDER_FLOW_STAGES: ServiceOrderFlowStage[];
+export declare const SERVICE_CROSS_OBJECT_BINDINGS: ServiceCrossObjectBinding[];
+export declare const SERVICE_SCENES: ServiceScene[];
+export declare const SERVICE_LEDGER_VERSION = "1.0.0";
+export declare function getScenesByCategory(category: ServiceScene["category"]): ServiceScene[];
+export declare function findSceneById(id: string): ServiceScene | undefined;
+export declare function getServicePermissionByIndex(index: number): ServicePermissionEntry | undefined;
+export declare function isServicePermission(index: number): boolean;
+export declare function getPermissionsByMutability(mutability: ServicePermissionEntry["post_publish_mutability"]): ServicePermissionEntry[];
+export declare function getImmutablePostPublishPermissions(): ServicePermissionEntry[];
+export declare function getLockedByDurationPermissions(): ServicePermissionEntry[];
+export declare function inferSceneFromIntent(intent: string): ServiceScene | undefined;
+export declare function getAllServiceScenes(): ServiceScene[];
+export declare function getServiceScenesCount(): number;
+export declare function getServicePermissionsCount(): number;
+export declare function getOrderFlowStage(stage: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8): ServiceOrderFlowStage | undefined;
+export declare function getCrossObjectBindings(): ServiceCrossObjectBinding[];