@wowok/agent-mcp 2.5.2 → 2.5.3

package/dist/loop-engineering/improve.js

@@ -1,4 +1,7 @@
 import { getPendingSuggestions } from "../knowledge/flywheel-loop.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
 function proposeErrorRuleAddition(diagnosis) {
     const evidence = diagnosis.evidence;
     const topMessages = evidence.top_error_messages || [];
@@ -20,6 +23,7 @@ function proposeErrorRuleAddition(diagnosis) {
         type: "error_rule_addition",
         priority: diagnosis.severity,
         automation: "semi",
+        apply_mode: "source_patch",
         title: `Add ERROR_RULES entries for ${diagnosis.target}`,
         description: `Generate new error classification rules to cover patterns currently falling into 'unknown'. AI should draft regex patterns; human reviewer validates accuracy and assigns correct error_code.`,
         target: "ERROR_RULES",
@@ -47,6 +51,8 @@ function proposeDescriptionRewrite(diagnosis) {
         type: "description_rewrite",
         priority: diagnosis.severity,
         automation: "semi",
+        apply_mode: "config_override",
+        override_category: "descriptions",
         title: `Rewrite description for ${evidence.tool_name || diagnosis.target}`,
         description: `The semantic layer produces no summary for ${((1 - (evidence.semantic_hit_rate || 0)) * 100).toFixed(1)}% of calls to this tool. AI should rewrite the tool description and INTENT_RULES to improve coverage. A/B test before merging.`,
         target: diagnosis.target,
@@ -73,6 +79,7 @@ function proposeSkillCreation(diagnosis) {
         type: "skill_creation",
         priority: diagnosis.severity,
         automation: "semi",
+        apply_mode: "source_patch",
         title: `Create new Skill for '${evidence.operation_type}' operations`,
         description: `This operation type has a ${(evidence.success_rate ? (1 - evidence.success_rate) * 100 : 0).toFixed(1)}% failure rate across ${evidence.total_calls} calls. A Skill with R1-R10 dialogue scripts, decision trees, and failure playbooks could guide users to success.`,
         target: `wowok-${evidence.operation_type}-guide`,
@@ -99,6 +106,8 @@ function proposeRecoveryAdjustment(diagnosis) {
         type: "recovery_priority_adjustment",
         priority: diagnosis.severity,
         automation: "semi",
+        apply_mode: "config_override",
+        override_category: "recovery-priorities",
         title: `Review recovery strategy for '${evidence.error_code}' errors`,
         description: `Error code '${evidence.error_code}' accounts for ${evidence.count} failures (${((evidence.percentage || 0) * 100).toFixed(1)}%). The current recovery strategy may need tuning — consider increasing max_attempts, adjusting automation level, or addressing the root cause.`,
         target: `RECOVERY_RULES['${evidence.error_code}']`,
@@ -124,6 +133,7 @@ function proposeInvestigation(diagnosis) {
         type: "investigation",
         priority: diagnosis.severity,
         automation: "manual",
+        apply_mode: "source_patch",
         title: diagnosis.title,
         description: `Manual investigation required. ${diagnosis.description}`,
         target: diagnosis.target,
@@ -162,6 +172,8 @@ function proposeIndustryUpdate(diagnosis) {
         type: "industry_update_application",
         priority: diagnosis.severity,
         automation: isHealthCritical ? "semi" : "manual",
+        apply_mode: "config_override",
+        override_category: "industry-profiles",
         title: `Apply ${pendingSuggestions.length} evolution suggestions for industry '${industry}'`,
         description: `Industry '${industry}' has health anomaly (health score ${evidence.health_score ?? "N/A"}, level ${evidence.health_level ?? "N/A"}). ` +
             `Has ${pendingSuggestions.length} pending evolution suggestions (${(evidence.high_priority_count ?? 0)} high priority). ` +
@@ -218,6 +230,11 @@ export function generateImprovements(report) {
     const summary = `${proposals.length} proposals generated from ${report.total_diagnoses} diagnoses. ` +
         `${p0Count} P0, ${semiCount} semi-automatic, ${abTestCount} recommend A/B testing. ` +
         `All proposals require human review before application.`;
+    try {
+        persistImprovementQueue(proposals);
+    }
+    catch {
+    }
     return {
         report_id: `IMPROVE-REPORT-${Date.now()}`,
         generated_date: new Date().toISOString(),
@@ -227,3 +244,164 @@ export function generateImprovements(report) {
         summary,
     };
 }
+function wowokRootDir() {
+    return process.env.WOWOK_CONFIG_DIR
+        ? process.env.WOWOK_CONFIG_DIR
+        : join(homedir(), ".wowok");
+}
+function improvementQueuePath() {
+    return join(wowokRootDir(), "improvement-queue.jsonl");
+}
+function overridesDir() {
+    return join(wowokRootDir(), "overrides");
+}
+function patchesDir() {
+    return join(wowokRootDir(), "patches");
+}
+export function persistImprovementQueue(proposals) {
+    if (proposals.length === 0)
+        return 0;
+    const queuePath = improvementQueuePath();
+    mkdirSync(dirname(queuePath), { recursive: true });
+    const now = new Date().toISOString();
+    const lines = proposals.map((p) => JSON.stringify({ ...p, persisted_at: now }));
+    appendFileSync(queuePath, lines.join("\n") + "\n", "utf-8");
+    return proposals.length;
+}
+export function loadImprovementQueue(filter) {
+    const queuePath = improvementQueuePath();
+    if (!existsSync(queuePath))
+        return [];
+    const raw = readFileSync(queuePath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    const proposals = [];
+    for (const line of lines) {
+        try {
+            const p = JSON.parse(line);
+            if (filter?.status && p.review_status !== filter.status)
+                continue;
+            if (filter?.type && p.type !== filter.type)
+                continue;
+            if (filter?.priority && p.priority !== filter.priority)
+                continue;
+            proposals.push(p);
+        }
+        catch {
+        }
+    }
+    return proposals;
+}
+export function updateProposalReviewStatus(proposalId, newStatus) {
+    const all = loadImprovementQueue();
+    let updated;
+    const now = new Date().toISOString();
+    for (const p of all) {
+        if (p.proposal_id === proposalId) {
+            p.review_status = newStatus;
+            p.reviewed_at = now;
+            updated = p;
+        }
+    }
+    if (!updated)
+        return undefined;
+    const queuePath = improvementQueuePath();
+    if (all.length === 0) {
+        writeFileSync(queuePath, "", "utf-8");
+    }
+    else {
+        const lines = all.map((p) => JSON.stringify(p));
+        writeFileSync(queuePath, lines.join("\n") + "\n", "utf-8");
+    }
+    return updated;
+}
+export function applyConfigOverride(proposal) {
+    if (proposal.apply_mode !== "config_override") {
+        throw new Error(`Proposal ${proposal.proposal_id} has apply_mode=${proposal.apply_mode}, not config_override`);
+    }
+    if (!proposal.override_category) {
+        throw new Error(`Proposal ${proposal.proposal_id} has no override_category`);
+    }
+    const dir = overridesDir();
+    mkdirSync(dir, { recursive: true });
+    const filePath = join(dir, `${proposal.override_category}.json`);
+    let existing = {};
+    if (existsSync(filePath)) {
+        try {
+            existing = JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const merged = { ...existing, ...proposal.proposed_change, _last_applied_proposal: proposal.proposal_id, _last_applied_at: new Date().toISOString() };
+    writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf-8");
+    return filePath;
+}
+export function produceSourcePatch(proposal) {
+    if (proposal.apply_mode !== "source_patch") {
+        throw new Error(`Proposal ${proposal.proposal_id} has apply_mode=${proposal.apply_mode}, not source_patch`);
+    }
+    const dir = patchesDir();
+    mkdirSync(dir, { recursive: true });
+    const baseName = `${proposal.proposal_id}.md`;
+    const filePath = join(dir, baseName);
+    const content = [
+        `# Source Patch Proposal: ${proposal.title}`,
+        "",
+        `- **Proposal ID**: ${proposal.proposal_id}`,
+        `- **Type**: ${proposal.type}`,
+        `- **Priority**: ${proposal.priority}`,
+        `- **Target**: ${proposal.target}`,
+        `- **Generated**: ${new Date().toISOString()}`,
+        "",
+        "## Description",
+        proposal.description,
+        "",
+        "## Proposed Change",
+        "```json",
+        JSON.stringify(proposal.proposed_change, null, 2),
+        "```",
+        "",
+        "## Evidence",
+        "```json",
+        JSON.stringify(proposal.evidence, null, 2),
+        "```",
+        "",
+        "## Application",
+        "This proposal requires manual review and merge into the MCP source code.",
+        "Do NOT auto-apply. After merging, republish the MCP server.",
+        "",
+        "## Override Whiteline (§4.4)",
+        "This proposal type is NOT in the config_override whitelist and must go",
+        "through source patch (risk rules, skill structure, schema fields).",
+    ].join("\n");
+    writeFileSync(filePath, content, "utf-8");
+    return filePath;
+}
+export function getFlywheelConfigSummary() {
+    const all = loadImprovementQueue();
+    const overrideFiles = [];
+    const oDir = overridesDir();
+    if (existsSync(oDir)) {
+        try {
+            for (const f of readdirSync(oDir)) {
+                if (f.endsWith(".json"))
+                    overrideFiles.push(f);
+            }
+        }
+        catch {
+        }
+    }
+    return {
+        queue_path: improvementQueuePath(),
+        overrides_dir: oDir,
+        patches_dir: patchesDir(),
+        total_proposals: all.length,
+        pending_count: all.filter((p) => p.review_status === "pending").length,
+        approved_count: all.filter((p) => p.review_status === "approved").length,
+        applied_count: all.filter((p) => p.review_status === "applied").length,
+        rejected_count: all.filter((p) => p.review_status === "rejected").length,
+        override_files: overrideFiles,
+        recent_proposals: all.slice(-5),
+    };
+}

package/dist/project/context-assembly.d.ts

@@ -0,0 +1,16 @@
+import type { z } from "zod";
+import type { ProjectOperationInputSchema } from "../schema/project/index.js";
+import { type ContextCollectionResult } from "../loop-engineering/context-collect.js";
+type ValidatedInput = z.infer<typeof ProjectOperationInputSchema>;
+export interface AssembleContextResult {
+    action: "assemble_context";
+    objects: unknown[];
+    events?: unknown[];
+    embedded_history?: Record<string, unknown>;
+    semantic_summary?: unknown;
+    context_digest: string;
+    next_action: string;
+    flywheel_collected?: ContextCollectionResult;
+}
+export declare function assembleContext(validated: ValidatedInput): Promise<AssembleContextResult>;
+export {};

package/dist/project/context-assembly.js

@@ -0,0 +1,130 @@
+import { createHash } from "crypto";
+import { query_objects, query_events } from "@wowok/wowok";
+import { buildDataSemantic } from "../schema/call/semantic.js";
+import { collectContextExperience } from "../loop-engineering/context-collect.js";
+const STATE_TRANSITION_EVENTS = [
+    "NewOrderEvent",
+    "ProgressEvent",
+    "ArbEvent",
+    "DemandPresentEvent",
+    "DemandFeedbackEvent",
+    "NewEntityEvent",
+];
+export async function assembleContext(validated) {
+    const contextObjects = validated.context_objects;
+    if (!contextObjects || contextObjects.length === 0) {
+        throw new Error("assemble_context requires 'context_objects' — an array of object IDs or LocalMark names.");
+    }
+    const network = (validated.context_network ?? "testnet");
+    const includeEvents = validated.include_events ?? false;
+    const objectsResult = await query_objects({
+        objects: contextObjects,
+        no_cache: false,
+        network,
+    });
+    const objects = objectsResult?.objects ?? [];
+    const embeddedHistory = extractEmbeddedHistory(objects);
+    const hasEmbeddedHistory = Object.keys(embeddedHistory).length > 0;
+    let events;
+    if (includeEvents) {
+        events = [];
+        for (const eventType of STATE_TRANSITION_EVENTS) {
+            try {
+                const eventResult = await query_events({
+                    type: eventType,
+                    limit: 5,
+                    order: "descending",
+                    network,
+                });
+                if (eventResult?.data && eventResult.data.length > 0) {
+                    events.push(...eventResult.data);
+                }
+            }
+            catch {
+            }
+        }
+        if (events.length === 0) {
+            events = undefined;
+        }
+    }
+    const semanticCtx = {
+        operation_type: "assemble_context",
+        data: { context_objects: objects, embedded_history: embeddedHistory, events },
+    };
+    const semanticSummary = buildDataSemantic({ objects, embedded_history: embeddedHistory, events }, semanticCtx);
+    const digestParts = objects.map((obj) => `${obj?.object ?? obj?.data?.object ?? "?"}:${obj?.version ?? obj?.data?.version ?? "?"}`);
+    digestParts.push(`ts:${Date.now()}`);
+    const contextDigest = createHash("sha256")
+        .update(digestParts.join("|"))
+        .digest("hex")
+        .substring(0, 16);
+    const nextAction = hasEmbeddedHistory
+        ? "Context assembled with embedded operation history. Use onchain_transaction with a specific digest to verify a past operation, or proceed with onchain_operations (consider dry_run=true first to validate)."
+        : events && events.length > 0
+            ? "Context assembled with recent events. Use onchain_transaction with a specific digest to verify any event's tx, or proceed with onchain_operations."
+            : "Context assembled (current state only). Proceed with onchain_operations (consider dry_run=true first to validate).";
+    let flywheelCollected;
+    try {
+        flywheelCollected = collectContextExperience({
+            action: "assemble_context",
+            objects,
+            events,
+            embedded_history: hasEmbeddedHistory ? embeddedHistory : undefined,
+            semantic_summary: semanticSummary,
+            context_digest: contextDigest,
+            next_action: nextAction,
+        }, network);
+    }
+    catch {
+    }
+    return {
+        action: "assemble_context",
+        objects,
+        events,
+        embedded_history: hasEmbeddedHistory ? embeddedHistory : undefined,
+        semantic_summary: semanticSummary,
+        context_digest: contextDigest,
+        next_action: nextAction,
+        flywheel_collected: flywheelCollected,
+    };
+}
+function extractEmbeddedHistory(objects) {
+    const history = {};
+    for (const obj of objects) {
+        const data = obj?.data ?? obj;
+        const objectId = obj?.object ?? data?.object;
+        if (!objectId)
+            continue;
+        const objectType = data?.type ?? "";
+        const extracted = {};
+        if (objectType.includes("Progress") && data?.session?.forwards) {
+            extracted.operation_history = data.session.forwards.map((f) => ({
+                operation: f.forward,
+                operator: f.who,
+                accomplished: f.accomplished,
+                time: f.time,
+                message: f.msg,
+            }));
+            extracted.next_node = data.session?.next_node;
+            extracted.threshold = data.session?.threshold;
+        }
+        if (objectType.includes("Order")) {
+            if (data?.dispute && Array.isArray(data.dispute) && data.dispute.length > 0) {
+                extracted.disputes = data.dispute;
+            }
+            if (data?.claimed_by) {
+                extracted.claimed_by = data.claimed_by;
+            }
+            if (data?.progress) {
+                extracted.progress_object = data.progress;
+            }
+        }
+        if (objectType.includes("Service") && data?.sales) {
+            extracted.sale_count = Array.isArray(data.sales) ? data.sales.length : 0;
+        }
+        if (Object.keys(extracted).length > 0) {
+            history[objectId] = extracted;
+        }
+    }
+    return history;
+}

package/dist/project/deployment-doc.d.ts

@@ -70,3 +70,118 @@ export declare function generateDeploymentDoc(input: DeploymentDocInput): string
 export declare function estimateDeploymentGas(input: Pick<DeploymentDocInput, "objects">): GasEstimate;
 export declare function validateDeploymentDoc(input: DeploymentDocInput): DeploymentDocValidationResult;
 export declare function getStandardTopoOrder(): ProjectObjectType[];
+export interface StageGoal {
+    stage: 1 | 2 | 3 | 4 | 5;
+    goal_statement: string;
+    derived_from: string[];
+    success_criteria: Array<{
+        criterion_id: string;
+        description: string;
+        measurable: boolean;
+        target_value?: string;
+    }>;
+}
+export interface StageAssessment {
+    stage: 1 | 2 | 3 | 4 | 5;
+    assessed_at: number;
+    goal_completion: Record<string, number>;
+    findings: Array<{
+        finding_id: string;
+        severity: "info" | "warn" | "critical";
+        criterion_id: string;
+        description: string;
+        evidence: unknown;
+    }>;
+    recommendations: string[];
+}
+export interface StageRiskPolicy {
+    stage: 1 | 2 | 3 | 4 | 5;
+    risks: Array<{
+        risk_id: string;
+        category: "naming" | "dependency" | "operational" | "financial" | "security";
+        description: string;
+        likelihood: "low" | "medium" | "high";
+        impact: "low" | "medium" | "high" | "critical";
+        mitigation: string;
+        owner: "ai" | "user" | "system";
+    }>;
+    active_controls: Array<{
+        control_id: string;
+        control_type: "preventive" | "detective" | "corrective";
+        target_risk: string;
+        implementation: string;
+        verified: boolean;
+    }>;
+    residual_risks: string[];
+}
+export interface StageVerification {
+    stage: 1 | 2 | 3 | 4 | 5;
+    verified_at: number;
+    goal_verification: Record<string, {
+        passed: boolean;
+        evidence: unknown;
+    }>;
+    d_checks: Array<{
+        check_id: string;
+        status: "pass" | "fail" | "warn";
+        message: string;
+        evidence: unknown;
+    }>;
+    cross_stage_checks: Array<{
+        check_id: string;
+        involves_stages: number[];
+        description: string;
+        passed: boolean;
+        evidence: unknown;
+    }>;
+    stage_passed: boolean;
+    blocking_issues: string[];
+}
+export interface ValidationChainLink {
+    source_type: "project_invariant" | "project_goal";
+    source_id: string;
+    target_type: "stage_goal" | "stage_risk" | "stage_verification";
+    target_stage: 1 | 2 | 3 | 4 | 5;
+    target_id: string;
+    derivation_logic: string;
+}
+export interface PropagationRule {
+    rule_id: string;
+    trigger: {
+        stage: number;
+        event: "verification_passed" | "verification_failed";
+    };
+    effect: {
+        target: "project_invariant" | "next_stage";
+        action: "verify" | "block";
+    };
+}
+export interface ValidationChainGraph {
+    version: string;
+    generated_at: number;
+    project_invariants: Array<{
+        invariant_id: string;
+        description: string;
+        verified_by_stages: number[];
+    }>;
+    stage_units: Array<{
+        stage: 1 | 2 | 3 | 4 | 5;
+        goal_id: string;
+        assessment_id: string;
+        risk_policy_id: string;
+        verification_id: string;
+        artifacts: string[];
+    }>;
+    derivations: ValidationChainLink[];
+    propagation_rules: PropagationRule[];
+    impact_map: Record<string, string[]>;
+}
+export interface DeploymentDocSetResult {
+    readme_path: string;
+    relations_path: string;
+    stage_dirs: Record<1 | 2 | 3 | 4 | 5, string>;
+    all_files: string[];
+    relations: ValidationChainGraph;
+    all_stages_passed: boolean;
+}
+export declare function generateDeploymentDocSet(prefix: string, version: string, input: DeploymentDocInput): DeploymentDocSetResult;