@wowok/agent-mcp 2.5.0 → 2.5.2

package/dist/knowledge/mcp-schema-audit.js

@@ -484,7 +484,7 @@ export function analyzeHandlerTypeSafety(instances) {
 export function analyzeOutputSchemaCoverage(census) {
     const findings = [];
     for (const c of census) {
-        if (!c.layer3_generated.output_exists) {
+        if (!c.layer3_generated.output_exists && c.name !== "onchain_operations") {
             findings.push({
                 rule_id: 'MCP-OUTPUT-001',
                 severity: 'high',
@@ -559,7 +559,7 @@ export function analyzeSchemaQueryReflection(census) {
                 fix: `Run pnpm generate:schemas.`,
             });
         }
-        if (!c.layer3_generated.output_exists) {
+        if (!c.layer3_generated.output_exists && c.name !== "onchain_operations") {
             findings.push({
                 rule_id: 'MCP-REFLECT-002',
                 severity: 'medium',
@@ -574,6 +574,7 @@ export function analyzeSchemaQueryReflection(census) {
         'permission', 'service', 'machine', 'progress', 'guard',
         'arbitration', 'repository', 'contact', 'treasury', 'reward',
         'allocation', 'personal', 'payment', 'demand', 'order', 'gen_passport',
+        'proof', 'gen_proof',
     ];
     for (const op of onchainOps) {
         const opFile = path.join(GENERATED_SCHEMAS_DIR, `onchain_operations_${op}.schema.json`);

package/dist/project/business-puzzle.d.ts

@@ -26,6 +26,7 @@ export interface BusinessPuzzleResult {
     puzzles: Record<string, ObjectPuzzleEntry>;
     overall_completeness: "complete" | "partial" | "empty";
     next_step: string;
+    recommended_creation_order: string[];
     warnings: string[];
 }
 export interface KeywordMatch {

package/dist/project/business-puzzle.js

@@ -246,6 +246,7 @@ export function analyzeBusinessIntent(input) {
             puzzles: {},
             overall_completeness: "empty",
             next_step: "Please provide a non-empty business intent.",
+            recommended_creation_order: [],
             warnings: ["input.user_intent is empty"],
         };
     }
@@ -295,8 +296,17 @@ export function analyzeBusinessIntent(input) {
         puzzles,
         overall_completeness: overall,
         next_step: "",
+        recommended_creation_order: [],
         warnings,
     });
+    const creationOrder = [
+        "permission",
+        "progress",
+        "guard",
+        "allocation",
+        "machine",
+        "service",
+    ];
     return {
         intent_parsed: {
             primary_object: primary,
@@ -308,6 +318,7 @@ export function analyzeBusinessIntent(input) {
         puzzles,
         overall_completeness: overall,
         next_step: nextStep,
+        recommended_creation_order: creationOrder,
         warnings,
     };
 }

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

@@ -56,6 +56,17 @@ export interface DeploymentDocValidationResult {
     }>;
     errors: string[];
 }
+export interface GasEstimate {
+    total_gas_mist: number;
+    per_object: Array<{
+        entry_id: string;
+        object_type: string;
+        create_gas_mist: number;
+        publish_gas_mist: number;
+    }>;
+    publish_gas_mist: number;
+}
 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[];

package/dist/project/deployment-doc.js

@@ -300,6 +300,43 @@ export function generateDeploymentDoc(input) {
     ];
     return sections.filter((s) => s.length > 0).join("\n");
 }
+export function estimateDeploymentGas(input) {
+    const GAS_RATES = {
+        permission: { create: 20_000_000, publish: 0 },
+        progress: { create: 40_000_000, publish: 0 },
+        guard: { create: 30_000_000, publish: 0 },
+        allocation: { create: 40_000_000, publish: 0 },
+        machine: { create: 50_000_000, publish: 200_000_000 },
+        service: { create: 50_000_000, publish: 100_000_000 },
+        arb: { create: 40_000_000, publish: 0 },
+        treasury: { create: 30_000_000, publish: 0 },
+        demand: { create: 40_000_000, publish: 0 },
+        repository: { create: 40_000_000, publish: 0 },
+        reward: { create: 30_000_000, publish: 0 },
+    };
+    const perObject = [];
+    let totalGas = 0;
+    let publishGas = 0;
+    for (const obj of input.objects) {
+        const rate = GAS_RATES[obj.object_type] ?? { create: 40_000_000, publish: 0 };
+        const createGas = obj.reused_from ? 0 : rate.create;
+        const pubGas = obj.publish_required ? rate.publish : 0;
+        const objTotal = createGas + pubGas;
+        perObject.push({
+            entry_id: obj.entry_id,
+            object_type: obj.object_type,
+            create_gas_mist: createGas,
+            publish_gas_mist: pubGas,
+        });
+        totalGas += objTotal;
+        publishGas += pubGas;
+    }
+    return {
+        total_gas_mist: totalGas,
+        per_object: perObject,
+        publish_gas_mist: publishGas,
+    };
+}
 export function validateDeploymentDoc(input) {
     const errors = [];
     const checks = [];

package/dist/project/index.d.ts

@@ -7,6 +7,31 @@ export * from "./query.js";
 export declare function isProjectServiceEnabled(): boolean;
 export declare function getGraph(): ProjectGraph;
 export declare function setGraph(g: ProjectGraph): void;
+export type ProjectStage = 1 | 2 | 3 | 4 | 5;
+export interface StageCacheEntry {
+    stage: ProjectStage;
+    updated_at: number;
+    puzzles?: Record<string, unknown>;
+    risk_status?: string;
+    risk_can_proceed?: boolean;
+    doc_generated?: boolean;
+    doc_error_count?: number;
+    trace_coherent?: boolean;
+    trace_can_proceed?: boolean;
+    business_intent?: string;
+    industry?: string;
+}
+export declare function getStageCache(prefix: string, version: string): StageCacheEntry | undefined;
+export declare function updateStageCache(prefix: string, version: string, update: Partial<StageCacheEntry>): StageCacheEntry;
+export declare function getProjectStatus(prefix: string, version: string): {
+    stage: ProjectStage;
+    stage_name: string;
+    stage_description: string;
+    next_action: string;
+    can_proceed: boolean;
+    details: StageCacheEntry | undefined;
+};
+export declare function clearStageCache(prefix: string, version: string): void;
 export interface NormalizeCallInput {
     operation_type: string;
     data: any;

package/dist/project/index.js

@@ -62,6 +62,48 @@ export function getGraph() {
 export function setGraph(g) {
     GRAPH_INSTANCE = g;
 }
+const STAGE_CACHE = new Map();
+function stageCacheKey(prefix, version) {
+    return `${prefix}:${version}`;
+}
+export function getStageCache(prefix, version) {
+    return STAGE_CACHE.get(stageCacheKey(prefix, version));
+}
+export function updateStageCache(prefix, version, update) {
+    const key = stageCacheKey(prefix, version);
+    const existing = STAGE_CACHE.get(key);
+    const entry = {
+        stage: update.stage ?? existing?.stage ?? 1,
+        updated_at: Date.now(),
+        ...existing,
+        ...update,
+    };
+    STAGE_CACHE.set(key, entry);
+    return entry;
+}
+export function getProjectStatus(prefix, version) {
+    const entry = getStageCache(prefix, version);
+    const stage = entry?.stage ?? 1;
+    const stageInfo = {
+        1: { name: "Project Naming", description: "Project namespace established. Ready to analyze business intent.", next: "analyze_intent" },
+        2: { name: "Business Puzzle", description: "Business intent analyzed. Puzzles may need completion before risk assessment.", next: entry?.puzzles ? "aggregate_risks" : "analyze_intent" },
+        3: { name: "Risk Calibration", description: "Risks assessed. Fix CRITICAL risks before generating deployment doc.", next: entry?.risk_can_proceed ? "generate_deployment_doc" : "aggregate_risks" },
+        4: { name: "Deployment Document", description: "Deployment doc generated. Fix D-errors before substep trace.", next: entry?.doc_error_count === 0 ? "trace_substeps" : "generate_deployment_doc" },
+        5: { name: "Substep Trace", description: "Substeps traced. Ready for deployment execution.", next: entry?.trace_can_proceed ? "deploy" : "trace_substeps" },
+    };
+    const info = stageInfo[stage];
+    return {
+        stage,
+        stage_name: info.name,
+        stage_description: info.description,
+        next_action: info.next,
+        can_proceed: stage < 5,
+        details: entry,
+    };
+}
+export function clearStageCache(prefix, version) {
+    STAGE_CACHE.delete(stageCacheKey(prefix, version));
+}
 export function normalize(input) {
     if (!isProjectServiceEnabled()) {
         return { data: input.data, warnings: [] };

package/dist/project/risk-aggregator.d.ts

@@ -40,6 +40,13 @@ export interface RiskAggregationResult {
         entry_id: string;
     }>;
     calibrated_at: number;
+    fix_suggestions_grouped?: Record<string, Array<{
+        risk_rule_id: string;
+        severity: RiskSeverity;
+        message: string;
+        fix_suggestion: string;
+        entry_id: string;
+    }>>;
     warnings: string[];
 }
 export declare function aggregateProjectRisks(input: RiskAggregationInput): RiskAggregationResult;

package/dist/project/risk-aggregator.js

@@ -179,6 +179,20 @@ export function aggregateProjectRisks(input) {
             entry_id: f.entry_id,
         }));
     }
+    const fixSuggestionsGrouped = {};
+    for (const finding of findings) {
+        const key = finding.object_type;
+        if (!fixSuggestionsGrouped[key]) {
+            fixSuggestionsGrouped[key] = [];
+        }
+        fixSuggestionsGrouped[key].push({
+            risk_rule_id: finding.risk_rule_id,
+            severity: finding.severity,
+            message: finding.message,
+            fix_suggestion: finding.fix_suggestion,
+            entry_id: finding.entry_id,
+        });
+    }
     return {
         namespace: {
             prefix: input.project_prefix ?? "",
@@ -190,6 +204,7 @@ export function aggregateProjectRisks(input) {
         status,
         pending_confirmations,
         calibrated_at: Date.now(),
+        fix_suggestions_grouped: fixSuggestionsGrouped,
         warnings,
     };
 }

package/dist/schema/call/base.js

@@ -340,9 +340,9 @@ export const SchemaWarningSchema = z.object({
     }).describe("Server-side schema versions."),
 }).strict().describe("Schema compatibility warning attached to tool output when client_schema_version is provided and a mismatch is detected.");
 export const CallOutputSchema = z.object({
-    result: CallResultSchema.describe("Discriminated result. Check result.type first: 'transaction'|'submission'|'error'|'data'|'null'. Each variant has different fields."),
+    result: CallResultSchema.describe("Discriminated result. Check result.type first: 'transaction'|'submission'|'error'|'data'|'null'|'pending_confirmation'. Each variant has different fields."),
     message: z.string().optional().describe("Human-readable summary or hint. Constraint: always present for error/transaction results; may be omitted for data/null. Example: 'Transaction completed successfully'"),
     semantic: SemanticSummarySchema.optional().describe("Business semantic summary. AI should read semantic first; fall back to parsing result only when semantic is absent. Relation: populated by MCP server from operation context; undefined when intent cannot be confidently inferred or for non-transaction tools. Example: {intent:'publish_service', status:'success', summary:'...'}"),
     harness_report: HarnessReportSchema.optional().describe("L4 Harness report (Verify + Recover). Present only when the Harness is injected and an Expected Result was declared for this operation. Relation: produced by handler.ts calling harness.verify() and harness.recover(). Example: {verify:{status:'fail', mismatches:[...]}, recovery:{strategy:'recreate'}}"),
     schema_warning: SchemaWarningSchema.optional().describe("Schema compatibility warning. Present only when client_schema_version is provided in env and a mismatch is detected."),
-}).strict().describe("Unified MCP tool output. result.type discriminates 5 outcomes: 'transaction' (raw Wow response), 'submission' (needs Guard data), 'error' (failed with error_code), 'data' (query result), 'null' (no-op). When semantic is present, prefer it over raw result parsing. When harness_report is present, check verify.status first and follow recovery.strategy if status is 'fail'.");
+}).strict().describe("Unified MCP tool output. result.type discriminates 6 outcomes: 'transaction' (raw Wow response), 'submission' (needs Guard data), 'error' (failed with error_code), 'data' (query result), 'null' (no-op), 'pending_confirmation' (ConfirmGate blocked — re-call with env.confirmed=true). When semantic is present, prefer it over raw result parsing. When harness_report is present, check verify.status first and follow recovery.strategy if status is 'fail'.");