@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/config/runtime.d.ts

@@ -1,4 +1,5 @@
 export type ServiceName = "confirm_gate" | "project_service" | "harness" | "graph_persist" | "semantic_rich" | "experience_layer" | "customer_intelligence" | "order_monitor" | "industry_evolution";
+export type HarnessTier = "off" | "lightweight" | "full";
 interface ServiceMeta {
     name: ServiceName;
     description: string;
@@ -7,6 +8,9 @@ interface ServiceMeta {
     remindOnToggle: boolean;
 }
 export declare const SERVICE_REGISTRY: ServiceMeta[];
+export declare function getHarnessTier(): HarnessTier;
+export declare function setHarnessTier(tier: HarnessTier): void;
+export declare function resetHarnessTier(): void;
 export declare function isEnabled(service: ServiceName): boolean;
 export declare function setEnabled(service: ServiceName, enabled: boolean): void;
 export declare function toggle(service: ServiceName): boolean;

package/dist/config/runtime.js

@@ -18,8 +18,8 @@ export const SERVICE_REGISTRY = [
     },
     {
         name: "harness",
-        description: "L4 Harness verify/recover loop — automatically validates expected results before and after operations",
-        defaultEnabled: false,
+        description: "L4 Harness verify/recover loop — automatically validates expected results before and after operations. GLM5: default ON with tiered enforcement (off/lightweight/full).",
+        defaultEnabled: true,
         envVar: "WOWOK_HARNESS_ENABLED",
         remindOnToggle: true,
     },
@@ -68,6 +68,7 @@ export const SERVICE_REGISTRY = [
 ];
 const SERVICE_MAP = new Map(SERVICE_REGISTRY.map((s) => [s.name, s]));
 const runtimeOverrides = new Map();
+let harnessTierOverride;
 function configFilePath() {
     const dir = process.env.WOWOK_CONFIG_DIR
         ? process.env.WOWOK_CONFIG_DIR
@@ -103,8 +104,9 @@ function savePersisted() {
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
         const data = {
-            version: 1,
+            version: 2,
             services: Object.fromEntries(runtimeOverrides),
+            harness_tier: harnessTierOverride,
             updatedAt: Date.now(),
         };
         writeFileSync(path, JSON.stringify(data, null, 2), "utf-8");
@@ -119,7 +121,29 @@ function savePersisted() {
                 runtimeOverrides.set(name, enabled);
             }
         }
+        if (persisted.harness_tier) {
+            harnessTierOverride = persisted.harness_tier;
+        }
+    }
+}
+export function getHarnessTier() {
+    if (!isEnabled("harness"))
+        return "off";
+    if (harnessTierOverride)
+        return harnessTierOverride;
+    const envVal = process.env.WOWOK_HARNESS_TIER;
+    if (envVal === "off" || envVal === "lightweight" || envVal === "full") {
+        return envVal;
     }
+    return "lightweight";
+}
+export function setHarnessTier(tier) {
+    harnessTierOverride = tier;
+    savePersisted();
+}
+export function resetHarnessTier() {
+    harnessTierOverride = undefined;
+    savePersisted();
 }
 export function isEnabled(service) {
     if (runtimeOverrides.has(service)) {
@@ -192,8 +216,8 @@ function buildReminder(service, enabled) {
                 : "ProjectService is OFF: objects will not be automatically tagged with project membership. To enable, call config_operation toggle project_service.";
         case "harness":
             return enabled
-                ? "Harness is ON: automatically validates expected results after operations. May increase response time. To disable, call config_operation toggle harness."
-                : "Harness is OFF. To enable auto-validation, call config_operation toggle harness.";
+                ? `Harness is ON (tier: ${getHarnessTier()}): automatically validates expected results around operations. lightweight=Plan+Verify; full=Plan+Expect+Verify+Recover+Checkpoint. To change tier, set WOWOK_HARNESS_TIER or call harness API. To disable, call config_operation toggle harness.`
+                : "Harness is OFF. GLM5 recommends keeping it ON (lightweight tier) for safety. To enable, call config_operation toggle harness.";
         case "graph_persist":
             return enabled
                 ? "Graph persistence is ON: the object dependency graph will be saved to ~/.wowok/project-graph.json."

package/dist/harness/auto-escalation.d.ts

@@ -0,0 +1,27 @@
+import { type HarnessTier } from "../config/runtime.js";
+export type EscalationTrigger = "E1_CRITICAL_RISK" | "E2_OPERATION_CRITICAL" | "E3_SUBSTEP_FAILURE" | "E4_REPEATED_FAILURE";
+export interface EscalationEvent {
+    trigger: EscalationTrigger;
+    timestamp: string;
+    reason: string;
+    from_tier: HarnessTier;
+    to_tier: HarnessTier;
+}
+export interface EscalationState {
+    current_tier: HarnessTier;
+    history: EscalationEvent[];
+    recent_failures: Array<{
+        timestamp: number;
+        operation: string;
+        error_code: string;
+    }>;
+}
+export declare function isFullTier(tier: HarnessTier): boolean;
+export declare function shouldRunHeavyHooks(): boolean;
+export declare function shouldRunLightHooks(): boolean;
+export declare function recordCriticalRisk(description: string): EscalationEvent | null;
+export declare function recordCriticalOperation(operation: string, errorCode: string): EscalationEvent | null;
+export declare function recordSubstepFailure(detail: string): EscalationEvent | null;
+export declare function recordOperationFailure(operation: string, errorCode: string): EscalationEvent | null;
+export declare function getEscalationState(): Readonly<EscalationState>;
+export declare function resetEscalation(): void;

package/dist/harness/auto-escalation.js

@@ -0,0 +1,68 @@
+import { getHarnessTier, setHarnessTier } from "../config/runtime.js";
+const state = {
+    current_tier: "lightweight",
+    history: [],
+    recent_failures: [],
+};
+const REPEATED_FAILURE_WINDOW_MS = 60_000;
+const REPEATED_FAILURE_THRESHOLD = 3;
+export function isFullTier(tier) {
+    return tier === "full";
+}
+export function shouldRunHeavyHooks() {
+    return isFullTier(getHarnessTier());
+}
+export function shouldRunLightHooks() {
+    const tier = getHarnessTier();
+    return tier === "lightweight" || tier === "full";
+}
+export function recordCriticalRisk(description) {
+    return escalate("E1_CRITICAL_RISK", `CRITICAL risk detected: ${description}`);
+}
+export function recordCriticalOperation(operation, errorCode) {
+    return escalate("E2_OPERATION_CRITICAL", `Operation '${operation}' returned CRITICAL error: ${errorCode}`);
+}
+export function recordSubstepFailure(detail) {
+    return escalate("E3_SUBSTEP_FAILURE", `Substep trace reported failure: ${detail}`);
+}
+export function recordOperationFailure(operation, errorCode) {
+    const now = Date.now();
+    state.recent_failures.push({ timestamp: now, operation, error_code: errorCode });
+    state.recent_failures = state.recent_failures.filter((f) => now - f.timestamp <= REPEATED_FAILURE_WINDOW_MS);
+    if (state.recent_failures.length >= REPEATED_FAILURE_THRESHOLD) {
+        const summary = state.recent_failures
+            .map((f) => `${f.operation}:${f.error_code}`)
+            .join(", ");
+        return escalate("E4_REPEATED_FAILURE", `Repeated failures (${state.recent_failures.length} in ${REPEATED_FAILURE_WINDOW_MS / 1000}s): ${summary}`);
+    }
+    return null;
+}
+export function getEscalationState() {
+    return {
+        current_tier: getHarnessTier(),
+        history: [...state.history],
+        recent_failures: [...state.recent_failures],
+    };
+}
+export function resetEscalation() {
+    state.history = [];
+    state.recent_failures = [];
+    setHarnessTier("lightweight");
+    state.current_tier = "lightweight";
+}
+function escalate(trigger, reason) {
+    const fromTier = getHarnessTier();
+    if (fromTier !== "lightweight")
+        return null;
+    const event = {
+        trigger,
+        timestamp: new Date().toISOString(),
+        reason,
+        from_tier: fromTier,
+        to_tier: "full",
+    };
+    setHarnessTier("full");
+    state.current_tier = "full";
+    state.history.push(event);
+    return event;
+}

package/dist/index.js

@@ -5,6 +5,7 @@ import { readFileSync } from "fs";
 const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 import { OnchainOperationsSchema, WipOperationsSchema, WatchQueryOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, ProtocolInfoQuerySchema, CallOutputSchema, MessengerOperationInputSchema, MessengerOperationOutputSchema, createServerConfig, createCapabilitiesConfig, } from "./schema/index.js";
 import { areSchemasAvailable, getSchemaIndex, } from "./schema-query/index.js";
+import { syncDeployedToolDescriptors, shouldAutoSyncAtStartup, } from "./schema/sync-layer4.js";
 import { isProjectServiceEnabled, observe as projectObserve, } from "./project/index.js";
 import { registerSuccessHook } from "./schema/call/handler.js";
 import { listServices } from "./config/index.js";
@@ -132,6 +133,26 @@ async function main() {
     else {
         console.error("Schema files not available. Run 'npm run generate:schemas' to generate them.");
     }
+    if (shouldAutoSyncAtStartup()) {
+        try {
+            const r = syncDeployedToolDescriptors({ silent: true });
+            if (r.failed > 0) {
+                console.error(`Layer 4 auto-sync: ${r.ok}/${r.total} ok, ${r.failed} failed`);
+                for (const e of r.errors) {
+                    console.error(`  - ${e.tool}: ${e.error}`);
+                }
+            }
+            else {
+                console.error(`Layer 4 auto-sync: ${r.ok}/${r.total} tools restored`);
+            }
+        }
+        catch (e) {
+            console.error(`Layer 4 auto-sync skipped: ${e.message}`);
+        }
+    }
+    else {
+        console.error("Layer 4 auto-sync disabled (WOWOK_SYNC_LAYER4=never)");
+    }
     if (isProjectServiceEnabled()) {
         registerSuccessHook((result, context) => {
             if (context?.operation_type && context?.data) {

package/dist/knowledge/allocation-confirm.d.ts

@@ -0,0 +1,115 @@
+import { type AllocationRiskAssessment } from "./allocation-risk.js";
+export type ConfirmGateStatus = "approved" | "blocked_checklist" | "blocked_risk" | "blocked_user" | "blocked_environment";
+export interface ConfirmGateResult {
+    status: ConfirmGateStatus;
+    checklist_result: ChecklistResult;
+    risk_result?: AllocationRiskAssessment;
+    user_confirmation?: UserConfirmation;
+    environment_result?: EnvironmentResult;
+    confirmation_text?: string;
+    block_reason?: string;
+    decision_record: DecisionRecord;
+}
+export interface ChecklistResult {
+    all_passed: boolean;
+    items: ChecklistItem[];
+}
+export interface ChecklistItem {
+    id: string;
+    description: string;
+    passed: boolean;
+    message: string;
+}
+export interface UserConfirmation {
+    questions_asked: ConfirmationQuestion[];
+    responses: ConfirmationResponse[];
+    all_confirmed: boolean;
+}
+export interface ConfirmationQuestion {
+    id: string;
+    question: string;
+    requires_explicit_yes: boolean;
+    related_risk_ids?: string[];
+}
+export interface ConfirmationResponse {
+    question_id: string;
+    response: "yes" | "no" | "skip";
+}
+export interface EnvironmentResult {
+    passed: boolean;
+    checks: {
+        name: string;
+        passed: boolean;
+        message: string;
+    }[];
+}
+export interface DecisionRecord {
+    timestamp: string;
+    gate_version: string;
+    final_status: ConfirmGateStatus;
+    layers_passed: string[];
+    layers_failed: string[];
+}
+export interface AllocationJsonForConfirm {
+    object?: {
+        name: string;
+        type_parameter?: string;
+    } | string | null;
+    allocators?: {
+        description: string;
+        threshold: string | number;
+        allocators: {
+            guard: string;
+            sharing: {
+                who: {
+                    GuardIdentifier: number;
+                } | {
+                    Entity: string;
+                } | {
+                    Signer: "signer";
+                };
+                sharing: string | number;
+                mode: "Amount" | "Rate" | "Surplus";
+            }[];
+            fix?: string | number;
+            max?: string | number | null;
+        }[];
+    };
+    coin?: {
+        name?: string;
+        address?: string;
+    } | string;
+    payment_info?: object;
+    received_coins?: {
+        token_type: string;
+        received: {
+            id: string;
+            payment: string;
+        }[];
+    };
+    alloc_by_guard?: string;
+}
+export interface ConfirmGateInput {
+    allocation_json: AllocationJsonForConfirm;
+    intent?: string;
+    operation_type?: "create" | "receive" | "alloc_by_guard" | "query";
+    guard_signer_bindings?: Record<string, boolean>;
+    order_already_has_allocation?: boolean;
+    bound_order?: string;
+    guard_conditions_mutually_exclusive?: boolean;
+    referenced_treasuries_permissions?: Record<string, string>;
+    passport_identifier_types?: Record<number, string>;
+    skip_user_confirmation?: boolean;
+    skip_environment_check?: boolean;
+}
+export declare const ALLOCATION_PUBLISH_CHECKLIST: ChecklistItem[];
+export declare const ALLOCATION_CONFIRMATION_QUESTIONS: ConfirmationQuestion[];
+export declare const ALLOCATION_CONFIRM_VERSION = "1.0.0";
+export declare function runAllocationConfirmGate(input: ConfirmGateInput): ConfirmGateResult;
+export interface ProgressiveCheckResult {
+    stage: "checklist" | "risk" | "confirmation" | "environment" | "complete";
+    status: "pass" | "fail" | "pending";
+    message: string;
+    next_action?: string;
+}
+export declare function progressiveAllocationCheck(input: ConfirmGateInput): ProgressiveCheckResult;