@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/progress-context.js

@@ -0,0 +1,452 @@
+import { MAX_NAMED_OPERATOR_COUNT, MAX_NAMED_OPERATOR_ADDRESS_COUNT, MAX_CONTEXT_REPOSITORY_COUNT, } from "@wowok/wowok";
+import { PROGRESS_PERMISSIONS, PROGRESS_LEDGER_VERSION, PROGRESS_CROSS_OBJECT_REFS, inferSceneFromIntent, getScenesByIndustry, getScenesByPhase, getAllBuiltinPermissions, getProgressScenesCount, validateNamedOperatorAddressList, validateNamedOperatorCount, validateContextRepositoryCount, } from "./progress-ledger.js";
+import { initPuzzleFromIntent, checkPuzzleCompleteness, } from "./progress-puzzle.js";
+import { PROGRESS_RISK_VERSION, assessProgressRisks, getAllProgressRiskRules, getProgressRiskRulesCount, } from "./progress-risk.js";
+import { PROGRESS_TRANSLATION_VERSION, PROGRESS_SEMANTIC_TO_SCHEMA_RULES, PROGRESS_SCHEMA_TO_SEMANTIC_RULES, PROGRESS_CONSTRAINT_RULES, matchSemanticPattern, } from "./progress-translation.js";
+import { PROGRESS_TEMPLATES, PROGRESS_TEMPLATES_VERSION, getProgressTemplatesByScene, listProgressTemplates, } from "./progress-templates.js";
+import { PROGRESS_CONFIRM_VERSION, PROGRESS_OPERATION_CHECKLIST, PROGRESS_CONFIRMATION_QUESTIONS, } from "./progress-confirm.js";
+export const PROGRESS_CONTEXT_VERSION = "1.0.0";
+export function buildProgressContext(input) {
+    const max_length = input.max_length ?? 4000;
+    let matched_scene;
+    if (input.intent) {
+        matched_scene = inferSceneFromIntent(input.intent);
+    }
+    if (!matched_scene && input.target_phase) {
+        const phaseScenes = getScenesByPhase(input.target_phase);
+        if (phaseScenes.length > 0)
+            matched_scene = phaseScenes[0];
+    }
+    if (!matched_scene && input.target_industry) {
+        const industryScenes = getScenesByIndustry(input.target_industry);
+        if (industryScenes.length > 0)
+            matched_scene = industryScenes[0];
+    }
+    let matched_template;
+    if (matched_scene) {
+        const templates = getProgressTemplatesByScene(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({ rule_sentence: input.intent });
+        puzzle_completeness = checkPuzzleCompleteness(puzzle_state);
+    }
+    const relevant_risks = filterRiskRules(input.mode, input.stakeholder, matched_scene);
+    let risk_assessment;
+    if (input.mode === "pre_advance" && input.progress_json) {
+        const ctx = {
+            object: input.progress_json.object,
+            task: input.progress_json.task,
+            repository: input.progress_json.repository,
+            progress_namedOperator: input.progress_json.progress_namedOperator,
+            operate: input.progress_json.operate,
+            current_machine: input.current_machine,
+            machine_published: input.machine_published,
+            current_task: input.current_task,
+            current_named_operator_count: input.current_named_operator_count,
+            current_context_repository_count: input.current_context_repository_count,
+            current_node: input.current_node,
+            forward_already_accomplished: input.forward_already_accomplished,
+            holder_address: input.holder_address,
+            signer: input.signer,
+            forward_named_operator: input.forward_named_operator,
+            forward_permission_index: input.forward_permission_index,
+            forward_has_guard: input.forward_has_guard,
+            target_objects_types: input.target_objects_types,
+        };
+        risk_assessment = assessProgressRisks(ctx);
+    }
+    const relevant_checklist = filterChecklist(input.mode);
+    const relevant_questions = filterQuestions(input.mode);
+    const relevant_builtin_permissions = matched_scene
+        ? matched_scene.builtin_indexes_consumed
+        : getAllBuiltinPermissions();
+    const cross_object_refs = buildCrossObjectRefs(input.target_phase, matched_scene);
+    const onchain_constraints = buildOnchainConstraints();
+    const rendering_hints = buildRenderingHints(input.mode, max_length, input.progress_json?.operate?.op === "adminUnhold", !!input.progress_json?.task);
+    return {
+        version: PROGRESS_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,
+        cross_object_refs,
+        onchain_constraints,
+        rendering_hints,
+    };
+}
+function filterRiskRules(mode, stakeholder, scene) {
+    const allRules = getAllProgressRiskRules();
+    if (mode === "initial_design") {
+        return allRules.filter(r => r.category === "structural" || r.category === "lifecycle");
+    }
+    if (mode === "pre_advance") {
+        return allRules;
+    }
+    if (mode === "post_task_binding") {
+        return allRules.filter(r => r.id !== "R-PR-2-01");
+    }
+    if (mode === "stakeholder_review" && stakeholder) {
+        if (stakeholder === "owner") {
+            return allRules.filter(r => r.category === "permission" || r.category === "lifecycle" || r.category === "cross_object");
+        }
+        if (stakeholder === "named_operator") {
+            return allRules.filter(r => r.category === "permission" || r.id === "R-PR-4-02" || r.id === "R-PR-4-03");
+        }
+        if (stakeholder === "submitter") {
+            return allRules.filter(r => r.category === "semantic" || r.id === "R-PR-3-03" || r.id === "R-PR-4-02" || r.id === "R-PR-4-03");
+        }
+        if (stakeholder === "system") {
+            return allRules.filter(r => r.category === "cross_object" || r.category === "structural");
+        }
+    }
+    if (mode === "apply_check") {
+        return allRules.filter(r => r.category === "cross_object" || r.id === "R-PR-4-01");
+    }
+    return allRules;
+}
+function filterChecklist(mode) {
+    if (mode === "initial_design") {
+        return PROGRESS_OPERATION_CHECKLIST.filter(i => ["C-PR-01", "C-PR-03", "C-PR-04", "C-PR-05"].includes(i.id));
+    }
+    if (mode === "post_task_binding") {
+        return PROGRESS_OPERATION_CHECKLIST.filter(i => i.id !== "C-PR-06");
+    }
+    if (mode === "stakeholder_review") {
+        return PROGRESS_OPERATION_CHECKLIST.filter(i => ["C-PR-01", "C-PR-02", "C-PR-07", "C-PR-09", "C-PR-10"].includes(i.id));
+    }
+    return PROGRESS_OPERATION_CHECKLIST;
+}
+function filterQuestions(mode) {
+    if (mode === "pre_advance") {
+        return PROGRESS_CONFIRMATION_QUESTIONS;
+    }
+    if (mode === "post_task_binding") {
+        return PROGRESS_CONFIRMATION_QUESTIONS.filter(q => q.id !== "QPR2");
+    }
+    if (mode === "initial_design") {
+        return PROGRESS_CONFIRMATION_QUESTIONS.filter(q => q.id === "QPR5");
+    }
+    return [];
+}
+function buildCrossObjectRefs(targetPhase, scene) {
+    const refs = PROGRESS_CROSS_OBJECT_REFS.map(r => ({
+        object: r.object,
+        phase: r.phase,
+        relationship: r.relationship,
+        description: r.relationship,
+    }));
+    if (targetPhase) {
+        return refs.filter(r => r.phase === targetPhase || r.phase === "universal");
+    }
+    if (scene) {
+        const scenePhases = scene.phases;
+        return refs.filter(r => r.phase === "universal" || scenePhases.includes(r.phase));
+    }
+    return refs;
+}
+function buildOnchainConstraints() {
+    return [
+        {
+            name: "MAX_NAMED_OPERATOR_COUNT",
+            value: MAX_NAMED_OPERATOR_COUNT,
+            description: "Maximum named_operator namespace entries per Progress",
+            error_code: "E_MAX_NAMED_OPERATOR_COUNT",
+        },
+        {
+            name: "MAX_NAMED_OPERATOR_ADDRESS_COUNT",
+            value: MAX_NAMED_OPERATOR_ADDRESS_COUNT,
+            description: "Maximum addresses per named_operator namespace entry",
+            error_code: "E_MAX_NAMED_OPERATOR_ADDRESS_COUNT",
+        },
+        {
+            name: "MAX_CONTEXT_REPOSITORY_COUNT",
+            value: MAX_CONTEXT_REPOSITORY_COUNT,
+            description: "Maximum context_repositories per Progress",
+            error_code: "E_MAX_CONTEXT_REPOSITORY_COUNT",
+        },
+        {
+            name: "PROGRESS_NEW (220)",
+            value: 220,
+            description: "Builtin: create new Progress (asserted by progress::new / new_with_passport; bypassed by service::buy → new_imp)",
+        },
+        {
+            name: "PROGRESS_NAMED_OPERATOR (221)",
+            value: 221,
+            description: "Builtin: manage named_operator namespace (add/set/remove)",
+        },
+        {
+            name: "PROGRESS_TASK (222)",
+            value: 222,
+            description: "Builtin: submit task (one-time, immutable — E_TASK_ALREADY_SET)",
+            error_code: "E_TASK_ALREADY_SET",
+        },
+        {
+            name: "PROGRESS_CONTEXT_REPOSITORY (223)",
+            value: 223,
+            description: "Builtin: bind/unbind context Repository (≤ 30)",
+        },
+        {
+            name: "PROGRESS_UNHOLD (224)",
+            value: 224,
+            description: "Builtin: adminUnhold (force release, bypasses holder check)",
+            error_code: "E_NOT_THE_HOLDER",
+        },
+        {
+            name: "PROGRESS_OWNER_RECEIVE (225)",
+            value: 225,
+            description: "Builtin: owner receive (unwrap Receiving<K> / CoinWrapper<T> at terminal node)",
+        },
+        {
+            name: "E_MACHINE_NOT_MATCH",
+            value: 4,
+            description: "Move error: progress.machine ≠ machine.id_address (every op asserts this)",
+        },
+        {
+            name: "E_FORWARD_ALREADY_ACCOMPLISHED",
+            value: 7,
+            description: "Move error: re-hold on completed forward is blocked",
+        },
+        {
+            name: "E_NEED_PASSPORT",
+            value: 9,
+            description: "Move error: Forward.guard is Some but plain next() called — use *_with_passport variant",
+        },
+        {
+            name: "E_ORDER_NOT_MATCH",
+            value: 10,
+            description: "Move error: order_next/order_hold called but progress.task ≠ order address",
+        },
+    ];
+}
+function buildRenderingHints(mode, max_length, hasAdminUnhold, hasTaskSet) {
+    return {
+        include_puzzle_template: mode === "initial_design",
+        include_risk_details: mode === "pre_advance" || mode === "stakeholder_review",
+        include_questions: mode === "pre_advance",
+        include_immutability_warning: hasTaskSet || mode === "post_task_binding",
+        include_admin_unhold_warning: hasAdminUnhold,
+        include_cross_object_refs: mode === "apply_check" || mode === "initial_design",
+        include_terminal_node_note: mode === "post_task_binding" || mode === "pre_advance",
+        max_length,
+    };
+}
+export function buildPromptFromProgressContext(bundle) {
+    const lines = [];
+    const h = bundle.rendering_hints;
+    lines.push(`═══ Progress Context (mode: ${bundle.mode}) ═══`);
+    lines.push("");
+    if (bundle.stakeholder_perspective) {
+        lines.push(`Stakeholder perspective: ${bundle.stakeholder_perspective}`);
+        lines.push("");
+    }
+    if (bundle.matched_scene) {
+        lines.push(`Scene: ${bundle.matched_scene.name}`);
+        lines.push(`Phases: ${bundle.matched_scene.phases.join(", ")}`);
+        lines.push(`Requires published Machine: ${bundle.matched_scene.requires_published_machine ? "YES" : "NO"}`);
+        lines.push(`Requires Order bound: ${bundle.matched_scene.requires_order_bound ? "YES" : "NO"}`);
+        lines.push(`Uses hold mechanism: ${bundle.matched_scene.uses_hold_mechanism ? "YES" : "NO"}`);
+        lines.push(`Uses adminUnhold: ${bundle.matched_scene.uses_admin_unhold ? "YES" : "NO"}`);
+        lines.push("");
+    }
+    if (bundle.matched_template) {
+        lines.push(`Suggested template: ${bundle.matched_template.id} — ${bundle.matched_template.name}`);
+        lines.push("");
+    }
+    if (bundle.matched_pattern) {
+        lines.push(`Matched pattern: ${bundle.matched_pattern.id} — ${bundle.matched_pattern.pattern_name}`);
+        lines.push(`Intent: ${bundle.matched_pattern.semantic_intent}`);
+        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) {
+                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, 6)) {
+            lines.push(`  ${r.id} [${r.category}] — ${r.trigger}`);
+        }
+        if (bundle.relevant_risks.length > 6) {
+            lines.push(`  ... and ${bundle.relevant_risks.length - 6} 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.needs_human_review) {
+            lines.push("⚠️ Needs human review (HIGH/CRITICAL risks present)");
+        }
+        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) {
+            lines.push(`  [${p.index}] ${p.name}: ${p.description}`);
+        }
+        lines.push("");
+    }
+    if (h.include_immutability_warning) {
+        lines.push("⚠️ TASK IMMUTABILITY: task_set is ONE-TIME. E_TASK_ALREADY_SET blocks any re-assignment.");
+        lines.push("   Once Progress.task is bound to an Order/Reward, it cannot be changed.");
+        lines.push("");
+    }
+    if (h.include_admin_unhold_warning) {
+        lines.push("⚠️ ADMINUNHOLD (224): Force-release bypasses holder check.");
+        lines.push("   Grant 224 only to dedicated recovery addresses; log every invocation.");
+        lines.push("");
+    }
+    if (h.include_cross_object_refs && 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, 8)) {
+            lines.push(`  ${ref.object} [${ref.phase}]: ${ref.relationship}`);
+        }
+        if (bundle.cross_object_refs.length > 8) {
+            lines.push(`  ... and ${bundle.cross_object_refs.length - 8} more`);
+        }
+        lines.push("");
+    }
+    if (h.include_terminal_node_note) {
+        lines.push("─ Terminal Node Note ──────────────");
+        lines.push("At terminal nodes (completed/enforced/deposit_refunded/paid), use progress::owner_receive");
+        lines.push("to unwrap Receiving<K> / CoinWrapper<T> via Payment.unwrap_with_check.");
+        lines.push("Permission 225 (PROGRESS_OWNER_RECEIVE) required; recipient = Machine.permission owner.");
+        lines.push("");
+    }
+    if (bundle.onchain_constraints.length > 0) {
+        lines.push("─ On-chain Constraints ──────────────");
+        for (const c of bundle.onchain_constraints) {
+            const errPart = c.error_code ? ` (abort: ${c.error_code})` : "";
+            lines.push(`  ${c.name} = ${c.value} — ${c.description}${errPart}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function getProgressContextSummary(bundle) {
+    const parts = [
+        `mode=${bundle.mode}`,
+        `scene=${bundle.matched_scene?.id ?? "none"}`,
+        `risks=${bundle.relevant_risks.length}`,
+        `permissions=${bundle.relevant_builtin_permissions.length}`,
+        `cross_refs=${bundle.cross_object_refs.length}`,
+    ];
+    if (bundle.stakeholder_perspective)
+        parts.push(`stakeholder=${bundle.stakeholder_perspective}`);
+    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.matched_pattern)
+        parts.push(`pattern=${bundle.matched_pattern.id}`);
+    return parts.join(", ");
+}
+export function buildStakeholderContext(stakeholder, intent, progress_json) {
+    return buildProgressContext({
+        mode: "stakeholder_review",
+        intent,
+        progress_json,
+        stakeholder,
+    });
+}
+export function quickValidateProgressJson(progress_json, current_state = {}) {
+    const violations = [];
+    if (progress_json.progress_namedOperator) {
+        const check = validateNamedOperatorAddressList(progress_json.progress_namedOperator.operators);
+        if (!check.ok)
+            violations.push(...check.violations);
+        if ((progress_json.progress_namedOperator.op === "add" ||
+            progress_json.progress_namedOperator.op === "set") &&
+            current_state.current_named_operator_count !== undefined) {
+            const countCheck = validateNamedOperatorCount(current_state.current_named_operator_count);
+            if (!countCheck.ok)
+                violations.push(countCheck.violation);
+        }
+    }
+    if (progress_json.repository &&
+        (progress_json.repository.op === "add" || progress_json.repository.op === "set")) {
+        const addCount = progress_json.repository.objects.length;
+        const current = current_state.current_context_repository_count ?? 0;
+        const repoCheck = validateContextRepositoryCount(current, addCount);
+        if (!repoCheck.ok)
+            violations.push(repoCheck.violation);
+    }
+    if (progress_json.task && current_state.current_task) {
+        violations.push(`task already set to ${current_state.current_task} — E_TASK_ALREADY_SET will abort`);
+    }
+    if (current_state.machine_published === false) {
+        violations.push("Machine not published — Progress requires published Machine");
+    }
+    return { ok: violations.length === 0, violations };
+}
+export function getProgressKnowledgeSnapshot() {
+    return {
+        version: {
+            ledger: PROGRESS_LEDGER_VERSION,
+            puzzle: "1.0.0",
+            risk: PROGRESS_RISK_VERSION,
+            translation: PROGRESS_TRANSLATION_VERSION,
+            templates: PROGRESS_TEMPLATES_VERSION,
+            confirm: PROGRESS_CONFIRM_VERSION,
+            context: PROGRESS_CONTEXT_VERSION,
+        },
+        scenes_count: getProgressScenesCount(),
+        builtin_permissions_count: PROGRESS_PERMISSIONS.length,
+        builtin_permissions: PROGRESS_PERMISSIONS.map(p => ({
+            index: p.index,
+            name: p.name,
+            sdk_exposed: p.sdk_exposed,
+        })),
+        templates_count: PROGRESS_TEMPLATES.length,
+        templates: listProgressTemplates(),
+        semantic_patterns_count: PROGRESS_SEMANTIC_TO_SCHEMA_RULES.length,
+        schema_rules_count: PROGRESS_SCHEMA_TO_SEMANTIC_RULES.length,
+        constraint_rules_count: PROGRESS_CONSTRAINT_RULES.length,
+        risk_rules_count: getProgressRiskRulesCount(),
+        checklist_count: PROGRESS_OPERATION_CHECKLIST.length,
+        confirmation_questions_count: PROGRESS_CONFIRMATION_QUESTIONS.length,
+        cross_object_refs_count: PROGRESS_CROSS_OBJECT_REFS.length,
+        onchain_limits: {
+            max_named_operator_count: MAX_NAMED_OPERATOR_COUNT,
+            max_named_operator_address_count: MAX_NAMED_OPERATOR_ADDRESS_COUNT,
+            max_context_repository_count: MAX_CONTEXT_REPOSITORY_COUNT,
+        },
+        injection_modes: [
+            "initial_design",
+            "mid_progress_review",
+            "pre_advance",
+            "post_task_binding",
+            "stakeholder_review",
+            "apply_check",
+        ],
+        stakeholders: ["owner", "named_operator", "submitter", "system"],
+    };
+}

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

@@ -0,0 +1,63 @@
+import { MAX_NAMED_OPERATOR_COUNT, MAX_NAMED_OPERATOR_ADDRESS_COUNT, MAX_CONTEXT_REPOSITORY_COUNT } from "@wowok/wowok";
+export { MAX_NAMED_OPERATOR_COUNT, MAX_NAMED_OPERATOR_ADDRESS_COUNT, MAX_CONTEXT_REPOSITORY_COUNT, };
+export type ProgressPhase = "creation" | "task_binding" | "named_operator_mgmt" | "context_binding" | "forward_advance" | "hold_state" | "unhold_state" | "owner_receive" | "completed";
+export interface ProgressBuiltinPermissionEntry {
+    index: 220 | 221 | 222 | 223 | 224 | 225;
+    name: string;
+    description: string;
+    governed_operations: string[];
+    sdk_exposed: boolean;
+}
+export interface ProgressScene {
+    id: string;
+    name: string;
+    industry: string[];
+    scenario: string;
+    phases: ProgressPhase[];
+    requires_published_machine: true;
+    requires_order_bound: boolean;
+    named_operator_roles: {
+        role: string;
+        typical_count: number;
+    }[];
+    builtin_indexes_consumed: ProgressBuiltinPermissionEntry[];
+    typical_context_repository_count: number;
+    uses_hold_mechanism: boolean;
+    uses_admin_unhold: boolean;
+    common_patterns: string[];
+    recommended_templates: string[];
+}
+export declare const PROGRESS_NEW: ProgressBuiltinPermissionEntry;
+export declare const PROGRESS_NAMED_OPERATOR: ProgressBuiltinPermissionEntry;
+export declare const PROGRESS_TASK: ProgressBuiltinPermissionEntry;
+export declare const PROGRESS_CONTEXT_REPOSITORY: ProgressBuiltinPermissionEntry;
+export declare const PROGRESS_UNHOLD: ProgressBuiltinPermissionEntry;
+export declare const PROGRESS_OWNER_RECEIVE: ProgressBuiltinPermissionEntry;
+export declare const PROGRESS_PERMISSIONS: ProgressBuiltinPermissionEntry[];
+export declare const PROGRESS_SCENES: ProgressScene[];
+export declare const PROGRESS_LEDGER_VERSION = "1.0.0";
+export declare function getScenesByPhase(phase: ProgressPhase): ProgressScene[];
+export declare function findSceneById(id: string): ProgressScene | undefined;
+export declare function getScenesByIndustry(industry: string): ProgressScene[];
+export declare function getBuiltinPermissionByIndex(index: number): ProgressBuiltinPermissionEntry | undefined;
+export declare function isProgressBuiltinPermission(index: number): boolean;
+export declare function inferSceneFromIntent(intent: string): ProgressScene | undefined;
+export declare function getAllBuiltinPermissions(): ProgressBuiltinPermissionEntry[];
+export declare function getProgressScenesCount(): number;
+export declare function validateNamedOperatorAddressList(addresses: string[]): {
+    ok: boolean;
+    violations: string[];
+};
+export declare function validateNamedOperatorCount(currentNamedOperatorCount: number): {
+    ok: boolean;
+    violation?: string;
+};
+export declare function validateContextRepositoryCount(currentRepositoryCount: number, addCount: number): {
+    ok: boolean;
+    violation?: string;
+};
+export declare const PROGRESS_CROSS_OBJECT_REFS: Array<{
+    object: "Machine" | "Order" | "Repository" | "Permission" | "Service" | "Passport" | "Payment" | "Allocation";
+    phase: ProgressPhase | "universal";
+    relationship: string;
+}>;