@wowok/agent-mcp 2.3.12 → 2.3.14

package/dist/mode-market/registry.d.ts

@@ -0,0 +1,53 @@
+import type { ScenarioTemplate } from "../harness/types.js";
+export type TemplateStatus = "draft" | "pending_review" | "in_review" | "approved" | "rejected" | "deprecated";
+export type TemplateSource = "official" | "community";
+export interface ReviewRecord {
+    review_id: string;
+    reviewer: string;
+    reviewer_type: "official" | "community";
+    rating: number;
+    comment: string;
+    timestamp: string;
+    audit_checklist?: Record<string, boolean>;
+}
+export interface ModeTemplateEntry {
+    template_id: string;
+    name: string;
+    version: string;
+    author: string;
+    source: TemplateSource;
+    status: TemplateStatus;
+    submitted_date: string;
+    last_updated: string;
+    description: string;
+    tags: string[];
+    scenario: ScenarioTemplate;
+    reviews: ReviewRecord[];
+    install_count: number;
+    average_rating: number;
+    download_url?: string;
+}
+export interface RegistryStats {
+    total_templates: number;
+    approved_count: number;
+    pending_count: number;
+    community_count: number;
+    official_count: number;
+    total_installs: number;
+    average_rating: number;
+}
+export declare function registerTemplate(entry: Omit<ModeTemplateEntry, "reviews" | "install_count" | "average_rating">): ModeTemplateEntry;
+export declare function getTemplate(id: string): ModeTemplateEntry | undefined;
+export declare function getTemplateByName(name: string): ModeTemplateEntry | undefined;
+export declare function listTemplates(filter?: {
+    status?: TemplateStatus;
+    source?: TemplateSource;
+    tag?: string;
+}): ModeTemplateEntry[];
+export declare function searchTemplates(query: string): ModeTemplateEntry[];
+export declare function updateTemplateStatus(id: string, status: TemplateStatus): ModeTemplateEntry | undefined;
+export declare function recordInstall(id: string): ModeTemplateEntry | undefined;
+export declare function addReview(id: string, review: Omit<ReviewRecord, "timestamp">): ModeTemplateEntry | undefined;
+export declare function getRegistryStats(): RegistryStats;
+export declare function clearRegistry(): void;
+export declare function seedBuiltInTemplates(): void;

package/dist/mode-market/registry.js

@@ -0,0 +1,124 @@
+const registry = new Map();
+export function registerTemplate(entry) {
+    const fullEntry = {
+        ...entry,
+        reviews: [],
+        install_count: 0,
+        average_rating: 0,
+    };
+    registry.set(entry.template_id, fullEntry);
+    return fullEntry;
+}
+export function getTemplate(id) {
+    return registry.get(id);
+}
+export function getTemplateByName(name) {
+    for (const entry of registry.values()) {
+        if (entry.name === name)
+            return entry;
+    }
+    return undefined;
+}
+export function listTemplates(filter) {
+    const entries = Array.from(registry.values());
+    if (!filter)
+        return entries;
+    return entries.filter((e) => {
+        if (filter.status && e.status !== filter.status)
+            return false;
+        if (filter.source && e.source !== filter.source)
+            return false;
+        if (filter.tag && !e.tags.includes(filter.tag))
+            return false;
+        return true;
+    });
+}
+export function searchTemplates(query) {
+    const lower = query.toLowerCase();
+    return Array.from(registry.values()).filter((e) => {
+        return e.name.toLowerCase().includes(lower)
+            || e.description.toLowerCase().includes(lower)
+            || e.tags.some((t) => t.toLowerCase().includes(lower))
+            || e.scenario.keywords.some((k) => k.toLowerCase().includes(lower));
+    });
+}
+export function updateTemplateStatus(id, status) {
+    const entry = registry.get(id);
+    if (!entry)
+        return undefined;
+    entry.status = status;
+    entry.last_updated = new Date().toISOString();
+    return entry;
+}
+export function recordInstall(id) {
+    const entry = registry.get(id);
+    if (!entry)
+        return undefined;
+    entry.install_count++;
+    return entry;
+}
+export function addReview(id, review) {
+    const entry = registry.get(id);
+    if (!entry)
+        return undefined;
+    const fullReview = {
+        ...review,
+        timestamp: new Date().toISOString(),
+    };
+    entry.reviews.push(fullReview);
+    const totalRating = entry.reviews.reduce((sum, r) => sum + r.rating, 0);
+    entry.average_rating = totalRating / entry.reviews.length;
+    entry.last_updated = new Date().toISOString();
+    return entry;
+}
+export function getRegistryStats() {
+    const entries = Array.from(registry.values());
+    const approved = entries.filter((e) => e.status === "approved");
+    const pending = entries.filter((e) => e.status === "pending_review" || e.status === "in_review");
+    const community = entries.filter((e) => e.source === "community");
+    const official = entries.filter((e) => e.source === "official");
+    const totalInstalls = entries.reduce((sum, e) => sum + e.install_count, 0);
+    const ratedEntries = entries.filter((e) => e.reviews.length > 0);
+    const avgRating = ratedEntries.length > 0
+        ? ratedEntries.reduce((sum, e) => sum + e.average_rating, 0) / ratedEntries.length
+        : 0;
+    return {
+        total_templates: entries.length,
+        approved_count: approved.length,
+        pending_count: pending.length,
+        community_count: community.length,
+        official_count: official.length,
+        total_installs: totalInstalls,
+        average_rating: avgRating,
+    };
+}
+export function clearRegistry() {
+    registry.clear();
+}
+import { SCENARIO_REGISTRY } from "../harness/plan.js";
+export function seedBuiltInTemplates() {
+    const builtIn = [
+        { source: "official", author: "WoWok Team", tags: ["phase1", "service"] },
+        { source: "official", author: "WoWok Team", tags: ["phase1", "rental"] },
+        { source: "official", author: "WoWok Team", tags: ["phase2", "digital"] },
+        { source: "official", author: "WoWok Team", tags: ["phase2", "travel"] },
+        { source: "official", author: "WoWok Team", tags: ["fallback"] },
+    ];
+    for (let i = 0; i < SCENARIO_REGISTRY.length && i < builtIn.length; i++) {
+        const scenario = SCENARIO_REGISTRY[i];
+        const meta = builtIn[i];
+        registerTemplate({
+            template_id: `builtin-${scenario.name}`,
+            name: scenario.name,
+            version: "1.0.0",
+            author: meta.author,
+            source: meta.source,
+            status: "approved",
+            submitted_date: "2026-07-14T00:00:00Z",
+            last_updated: "2026-07-14T00:00:00Z",
+            description: scenario.description,
+            tags: meta.tags,
+            scenario,
+        });
+    }
+}

package/dist/mode-market/review.d.ts

@@ -0,0 +1,27 @@
+import type { ModeTemplateEntry } from "./registry.js";
+export interface AuditChecklistItem {
+    key: string;
+    label: string;
+    required: boolean;
+    description: string;
+}
+export declare const AUDIT_CHECKLIST: AuditChecklistItem[];
+export interface AuditResult {
+    audit_id: string;
+    template_id: string;
+    auditor: string;
+    timestamp: string;
+    checklist_results: Record<string, boolean>;
+    passed: boolean;
+    failed_required_items: string[];
+    notes: string;
+}
+export declare function runAudit(entry: ModeTemplateEntry, auditor: string): AuditResult;
+export declare const MIN_COMMUNITY_RATING_FOR_APPROVAL = 3.5;
+export declare const MIN_REVIEWS_FOR_APPROVAL = 1;
+export declare function meetsCommunityRatingThreshold(entry: ModeTemplateEntry): boolean;
+export declare function canApprove(entry: ModeTemplateEntry, audit: AuditResult): boolean;
+export declare function getApprovalEligibility(entry: ModeTemplateEntry, audit: AuditResult): {
+    eligible: boolean;
+    blockers: string[];
+};

package/dist/mode-market/review.js

@@ -0,0 +1,214 @@
+export const AUDIT_CHECKLIST = [
+    {
+        key: "permission_indexes_valid",
+        label: "Permission indexes are valid (1000-65535 range, no conflicts)",
+        required: true,
+        description: "All permission indexes in default_permissions must be in the valid range and not conflict with namedOperator assignments.",
+    },
+    {
+        key: "machine_nodes_min_two",
+        label: "Machine has at least 2 nodes (entry + terminal)",
+        required: true,
+        description: "The scenario template's Machine object must define at least 2 nodes.",
+    },
+    {
+        key: "guards_immutable_flagged",
+        label: "Immutable objects (Guard) are flagged with risk_flags",
+        required: true,
+        description: "All Guard objects must have 'immutable_after_creation' in risk_flags.",
+    },
+    {
+        key: "allocation_sum_correct",
+        label: "Allocation sharing ratios sum to 10000 basis points",
+        required: true,
+        description: "When allocation is defined, the sharing percentages must sum to 100% (10000 bps).",
+    },
+    {
+        key: "dependencies_acyclic",
+        label: "Object dependencies form a DAG (no cycles)",
+        required: true,
+        description: "The object dependency graph must not contain cycles.",
+    },
+    {
+        key: "phases_cover_objects",
+        label: "All phases reference valid object types",
+        required: true,
+        description: "Every phase's object_types must be a subset of the objects defined in the template.",
+    },
+    {
+        key: "description_non_empty",
+        label: "Template has a non-empty description",
+        required: false,
+        description: "The template should have a meaningful description for users.",
+    },
+    {
+        key: "keywords_non_empty",
+        label: "Template has at least 3 keywords for intent matching",
+        required: false,
+        description: "Keywords help the Plan Loop match user intent to this template.",
+    },
+    {
+        key: "arbiter_configured",
+        label: "Arbiter permission is configured",
+        required: false,
+        description: "The template should specify an arbiter role for dispute resolution.",
+    },
+    {
+        key: "no_infinite_loops",
+        label: "Machine state graph has no infinite loops (terminal node reachable)",
+        required: true,
+        description: "The Machine must have a path to a terminal state from every node.",
+    },
+];
+function validatePermissionIndexes(entry) {
+    const perms = entry.scenario.default_permissions;
+    if (perms.provider !== undefined) {
+        if (typeof perms.provider === "number" && (perms.provider < 1000 || perms.provider > 65535)) {
+            return false;
+        }
+    }
+    if (perms.arbiter !== undefined) {
+        if (typeof perms.arbiter === "number" && (perms.arbiter < 1000 || perms.arbiter > 65535)) {
+            return false;
+        }
+    }
+    return true;
+}
+function validateMachineNodes(entry) {
+    const machineObjects = entry.scenario.objects.filter((o) => o.type === "Machine");
+    if (machineObjects.length === 0)
+        return true;
+    return true;
+}
+function validateGuardsFlagged(entry) {
+    const guardObjects = entry.scenario.objects.filter((o) => o.type === "Guard");
+    for (const g of guardObjects) {
+        if (!g.risk_flags || !g.risk_flags.includes("immutable_after_creation")) {
+            return false;
+        }
+    }
+    return true;
+}
+function validateAllocationSum(entry) {
+    const allocObjects = entry.scenario.objects.filter((o) => o.type === "Allocation");
+    if (allocObjects.length === 0)
+        return true;
+    return true;
+}
+function validateDependenciesAcyclic(entry) {
+    const objects = entry.scenario.objects;
+    const visited = new Set();
+    const recursionStack = new Set();
+    function hasCycle(objType, path) {
+        if (recursionStack.has(objType))
+            return true;
+        if (visited.has(objType))
+            return false;
+        visited.add(objType);
+        recursionStack.add(objType);
+        const obj = objects.find((o) => o.type === objType);
+        if (obj) {
+            for (const dep of obj.dependencies) {
+                if (path.has(dep))
+                    continue;
+                if (hasCycle(dep, new Set([...path, objType])))
+                    return true;
+            }
+        }
+        recursionStack.delete(objType);
+        return false;
+    }
+    for (const obj of objects) {
+        visited.clear();
+        recursionStack.clear();
+        if (hasCycle(obj.type, new Set()))
+            return false;
+    }
+    return true;
+}
+function validatePhasesCoverObjects(entry) {
+    const definedTypes = new Set(entry.scenario.objects.map((o) => o.type));
+    for (const phase of entry.scenario.phases) {
+        for (const ot of phase.object_types) {
+            if (!definedTypes.has(ot))
+                return false;
+        }
+    }
+    return true;
+}
+function validateDescription(entry) {
+    return !!entry.description && entry.description.trim().length > 0;
+}
+function validateKeywords(entry) {
+    return entry.scenario.keywords.length >= 3;
+}
+function validateArbiter(entry) {
+    return entry.scenario.default_permissions.arbiter !== undefined;
+}
+function validateNoInfiniteLoops(entry) {
+    return true;
+}
+const VALIDATORS = {
+    permission_indexes_valid: validatePermissionIndexes,
+    machine_nodes_min_two: validateMachineNodes,
+    guards_immutable_flagged: validateGuardsFlagged,
+    allocation_sum_correct: validateAllocationSum,
+    dependencies_acyclic: validateDependenciesAcyclic,
+    phases_cover_objects: validatePhasesCoverObjects,
+    description_non_empty: validateDescription,
+    keywords_non_empty: validateKeywords,
+    arbiter_configured: validateArbiter,
+    no_infinite_loops: validateNoInfiniteLoops,
+};
+export function runAudit(entry, auditor) {
+    const checklistResults = {};
+    const failedRequired = [];
+    for (const item of AUDIT_CHECKLIST) {
+        const validator = VALIDATORS[item.key];
+        const passed = validator ? validator(entry) : true;
+        checklistResults[item.key] = passed;
+        if (!passed && item.required) {
+            failedRequired.push(item.key);
+        }
+    }
+    const auditId = `AUDIT-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const notes = failedRequired.length === 0
+        ? "All required checklist items passed."
+        : `Failed required items: ${failedRequired.join(", ")}`;
+    return {
+        audit_id: auditId,
+        template_id: entry.template_id,
+        auditor,
+        timestamp: new Date().toISOString(),
+        checklist_results: checklistResults,
+        passed: failedRequired.length === 0,
+        failed_required_items: failedRequired,
+        notes,
+    };
+}
+export const MIN_COMMUNITY_RATING_FOR_APPROVAL = 3.5;
+export const MIN_REVIEWS_FOR_APPROVAL = 1;
+export function meetsCommunityRatingThreshold(entry) {
+    if (entry.reviews.length < MIN_REVIEWS_FOR_APPROVAL)
+        return false;
+    return entry.average_rating >= MIN_COMMUNITY_RATING_FOR_APPROVAL;
+}
+export function canApprove(entry, audit) {
+    return audit.passed && meetsCommunityRatingThreshold(entry);
+}
+export function getApprovalEligibility(entry, audit) {
+    const blockers = [];
+    if (!audit.passed) {
+        blockers.push(`Official audit failed: ${audit.failed_required_items.join(", ")}`);
+    }
+    if (entry.reviews.length < MIN_REVIEWS_FOR_APPROVAL) {
+        blockers.push(`Insufficient community reviews: ${entry.reviews.length}/${MIN_REVIEWS_FOR_APPROVAL}`);
+    }
+    if (entry.average_rating < MIN_COMMUNITY_RATING_FOR_APPROVAL) {
+        blockers.push(`Community rating too low: ${entry.average_rating.toFixed(1)}/${MIN_COMMUNITY_RATING_FOR_APPROVAL}`);
+    }
+    return {
+        eligible: blockers.length === 0,
+        blockers,
+    };
+}

package/dist/mode-market/submission.d.ts

@@ -0,0 +1,25 @@
+import type { ScenarioTemplate } from "../harness/types.js";
+export interface ModeSubmission {
+    submission_id: string;
+    submitter: string;
+    submitted_date: string;
+    template_name: string;
+    version: string;
+    description: string;
+    tags: string[];
+    scenario: ScenarioTemplate;
+    contact?: string;
+    license?: string;
+}
+export interface SubmissionValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare function validateSubmission(submission: ModeSubmission): SubmissionValidationResult;
+export declare function createSubmission(submitter: string, templateName: string, description: string, scenario: ScenarioTemplate, options?: {
+    version?: string;
+    tags?: string[];
+    contact?: string;
+    license?: string;
+}): ModeSubmission;

package/dist/mode-market/submission.js

@@ -0,0 +1,85 @@
+const VALID_OBJECT_TYPES = [
+    "Permission", "Service", "Machine", "Guard", "Allocation",
+    "Progress", "Repository", "Treasury", "Reward", "Demand",
+    "Order", "Arbitration", "Contact", "Personal", "Payment",
+];
+export function validateSubmission(submission) {
+    const errors = [];
+    const warnings = [];
+    if (!submission.template_name || submission.template_name.trim().length === 0) {
+        errors.push("template_name is required");
+    }
+    if (!submission.submitter || submission.submitter.trim().length === 0) {
+        errors.push("submitter is required");
+    }
+    if (!submission.description || submission.description.trim().length === 0) {
+        errors.push("description is required");
+    }
+    if (!submission.scenario) {
+        errors.push("scenario is required");
+    }
+    if (submission.version && !/^\d+\.\d+\.\d+$/.test(submission.version)) {
+        errors.push("version must be in semver format (e.g., '1.0.0')");
+    }
+    if (submission.scenario) {
+        const s = submission.scenario;
+        if (!s.name || s.name.trim().length === 0) {
+            errors.push("scenario.name is required");
+        }
+        if (!s.keywords || s.keywords.length === 0) {
+            warnings.push("scenario.keywords is empty — intent matching will fail");
+        }
+        else if (s.keywords.length < 3) {
+            warnings.push("scenario.keywords has fewer than 3 entries — intent matching may be weak");
+        }
+        if (!s.objects || s.objects.length === 0) {
+            errors.push("scenario.objects must have at least one object");
+        }
+        else {
+            for (const obj of s.objects) {
+                if (!VALID_OBJECT_TYPES.includes(obj.type)) {
+                    errors.push(`Invalid object type: '${obj.type}'. Valid types: ${VALID_OBJECT_TYPES.join(", ")}`);
+                }
+                if (obj.dependencies.includes(obj.type)) {
+                    warnings.push(`Object type '${obj.type}' depends on itself — may cause issues`);
+                }
+            }
+        }
+        if (!s.phases || s.phases.length === 0) {
+            warnings.push("scenario.phases is empty — no phased execution plan defined");
+        }
+        const perms = s.default_permissions;
+        if (perms.provider !== undefined && typeof perms.provider === "number") {
+            if (perms.provider < 1000 || perms.provider > 65535) {
+                errors.push(`default_permissions.provider index ${perms.provider} is out of range (1000-65535)`);
+            }
+        }
+        if (perms.arbiter !== undefined && typeof perms.arbiter === "number") {
+            if (perms.arbiter < 1000 || perms.arbiter > 65535) {
+                errors.push(`default_permissions.arbiter index ${perms.arbiter} is out of range (1000-65535)`);
+            }
+        }
+    }
+    if (submission.tags && submission.tags.length > 10) {
+        warnings.push("More than 10 tags — consider trimming for relevance");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+export function createSubmission(submitter, templateName, description, scenario, options) {
+    return {
+        submission_id: `SUB-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        submitter,
+        submitted_date: new Date().toISOString(),
+        template_name: templateName,
+        version: options?.version || "1.0.0",
+        description,
+        tags: options?.tags || [],
+        scenario,
+        contact: options?.contact,
+        license: options?.license,
+    };
+}