@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/flywheel-loop.d.ts

@@ -82,6 +82,9 @@ export declare const EVOLUTION_STATE_VERSION = 1;
 export declare function saveEvolutionState(): string;
 export declare function loadEvolutionState(): boolean;
 export declare function hasPersistedEvolutionState(): boolean;
+export declare function sanitizeSignal(signal: IndustrySignal): IndustrySignal;
+export declare function sanitizeDecisionContext(ctx: DecisionContext): DecisionContext;
+export declare function checkAndTriggerCognitionUpdate(industry: string): CognitionUpdateResult;
 export declare function _resetFlywheelLoopForTest(): void;
 export declare function _snapshotSignalBuffer(): Record<string, IndustrySignal[]>;
 export { MIN_SIGNALS_FOR_EVOLUTION as FLYWHEEL_LOOP_MIN_SIGNALS };

package/dist/knowledge/flywheel-loop.js

@@ -7,7 +7,10 @@ import { homedir } from "os";
 export const FLYWHEEL_LOOP_VERSION = 2;
 const MIN_SIGNALS_FOR_EVOLUTION = 10;
 const DEFAULT_SCHEDULE = {
-    mode: "manual",
+    mode: "semi_realtime",
+    signal_threshold: 20,
+    time_interval_ms: 5 * 60 * 1000,
+    auto_apply: false,
 };
 const industrySchedules = new Map();
 const industryLastUpdate = new Map();
@@ -21,13 +24,14 @@ export function recordIndustrySignal(industry, operation, outcome) {
     if (!industry)
         return;
     const resolved = resolveIndustryName(industry) ?? industry;
-    const signal = {
+    const rawSignal = {
         industry: resolved,
         operation_type: operation.type,
         success: outcome.success,
         error_code: outcome.error_code,
         timestamp: Date.now(),
     };
+    const signal = sanitizeSignal(rawSignal);
     const list = signalBuffer.get(resolved) ?? [];
     list.push(signal);
     signalBuffer.set(resolved, list);
@@ -112,7 +116,8 @@ export function getPendingSuggestions(industry) {
 export function recordDecisionContext(ctx, graph) {
     if (!ctx.id || !ctx.node_id)
         return;
-    decisionContexts.set(ctx.id, { ...ctx });
+    const sanitized = sanitizeDecisionContext(ctx);
+    decisionContexts.set(ctx.id, sanitized);
     if (graph) {
         try {
             graph.attachDecisionContext(ctx.node_id, {
@@ -362,6 +367,30 @@ export function loadEvolutionState() {
 export function hasPersistedEvolutionState() {
     return existsSync(evolutionStateFilePath());
 }
+export function sanitizeSignal(signal) {
+    return {
+        industry: signal.industry,
+        operation_type: signal.operation_type,
+        success: signal.success,
+        error_code: signal.error_code,
+        timestamp: signal.timestamp,
+        decision_context_id: signal.decision_context_id,
+    };
+}
+export function sanitizeDecisionContext(ctx) {
+    return {
+        id: ctx.id,
+        node_id: ctx.node_id,
+        decided_at: ctx.decided_at,
+        decider: ctx.decider,
+        industry: ctx.industry,
+        intent: ctx.intent,
+        outcome: ctx.outcome,
+    };
+}
+export function checkAndTriggerCognitionUpdate(industry) {
+    return updateIndustryCognition(industry);
+}
 export function _resetFlywheelLoopForTest() {
     signalBuffer.clear();
     decisionContexts.clear();

package/dist/knowledge/glossary.js

@@ -1,7 +1,9 @@
+import { USER_DEFINED_PERM_INDEX_START } from "./onchain-constants.js";
 export const CONCEPT_GLOSSARY = [
     {
         term: "Permission",
-        definition: "Organization-wide permission object. indices 0-999 builtin, 1000-65535 custom. " +
+        definition: `Organization-wide permission object. indices 0-${USER_DEFINED_PERM_INDEX_START - 1} builtin, ` +
+            `${USER_DEFINED_PERM_INDEX_START}-65535 custom. ` +
             "Shared across all Progress instances of a Service. Use for internal staff roles.",
         aliases: ["permission object"],
         category: "permission",

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

@@ -0,0 +1,86 @@
+import { type GuardRiskAssessment, type RiskLevel } from "./guard-risk.js";
+import { type GuardValidationIssue } from "@wowok/wowok";
+export type GuardConfirmGateStatus = "approved" | "blocked_checklist" | "blocked_risk" | "blocked_user" | "blocked_environment";
+export interface GuardConfirmGateResult {
+    status: GuardConfirmGateStatus;
+    checklist_result: GuardChecklistResult;
+    risk_result?: GuardRiskAssessmentResult;
+    user_confirmation?: GuardUserConfirmation;
+    environment_result?: GuardEnvironmentResult;
+    confirmation_text?: string;
+    block_reason?: string;
+    decision_record: GuardDecisionRecord;
+}
+export interface GuardChecklistResult {
+    passed: boolean;
+    checked_items: GuardChecklistItem[];
+    failed_items: GuardChecklistItem[];
+    warnings: GuardChecklistItem[];
+}
+export interface GuardChecklistItem {
+    id: string;
+    description: string;
+    status: "pass" | "fail" | "warning" | "skip";
+    detail?: string;
+}
+export interface GuardRiskAssessmentResult {
+    overall_risk_level: RiskLevel;
+    blocking_risks: string[];
+    warning_risks: string[];
+    recommendation: "publish" | "fix_first" | "do_not_publish";
+}
+export interface GuardUserConfirmation {
+    questions_asked: GuardConfirmationQuestion[];
+    user_responses: GuardConfirmationResponse[];
+    approved: boolean;
+    declined_reason?: string;
+    timestamp: string;
+}
+export interface GuardConfirmationQuestion {
+    id: string;
+    question: string;
+    expected_response: "yes" | "no" | "either";
+    blocking: boolean;
+    explanation?: string;
+}
+export interface GuardConfirmationResponse {
+    question_id: string;
+    response: "yes" | "no";
+    reason?: string;
+}
+export interface GuardEnvironmentResult {
+    testnet_tested: boolean;
+    binding_target_exists: boolean;
+    rely_chain_resolvable: boolean;
+    passport_generated_successfully: boolean;
+    warnings: string[];
+}
+export interface GuardDecisionRecord {
+    final_decision: "approved" | "blocked";
+    final_reason?: string;
+    timestamp: string;
+    layers_passed: ("checklist" | "risk" | "user" | "environment")[];
+}
+export interface GuardJsonForConfirm {
+    name?: string;
+    root: unknown;
+    description?: string;
+    binding_target?: string;
+    binding_scene_id?: string;
+}
+export declare const GUARD_PUBLISH_CHECKLIST: GuardChecklistItem[];
+export declare const GUARD_CONFIRMATION_QUESTIONS: GuardConfirmationQuestion[];
+export declare const GUARD_CONFIRM_VERSION = "1.0.0";
+export interface GuardConfirmGateInput {
+    guard_json: GuardJsonForConfirm;
+    skip_user_confirmation?: boolean;
+    skip_environment?: boolean;
+    existing_lint_issues?: GuardValidationIssue[];
+    existing_risk_assessment?: GuardRiskAssessment;
+    user_responses?: GuardConfirmationResponse[];
+}
+export declare function runGuardConfirmGate(input: GuardConfirmGateInput): GuardConfirmGateResult;
+export declare function progressiveGuardCheck(guard_json: GuardJsonForConfirm): {
+    layer: "checklist" | "risk" | "none";
+    result: GuardChecklistResult | GuardRiskAssessmentResult | null;
+};

package/dist/knowledge/guard-confirm.js

@@ -0,0 +1,406 @@
+import { assessGuardRisks, } from "./guard-risk.js";
+import { GUARD_SCENES, } from "./guard-ledger.js";
+export const GUARD_PUBLISH_CHECKLIST = [
+    {
+        id: "GC-01",
+        description: "Root node exists and is a valid GuardNode type",
+        status: "skip",
+    },
+    {
+        id: "GC-02",
+        description: "All table entries have valid value_type (0-18)",
+        status: "skip",
+    },
+    {
+        id: "GC-03",
+        description: "Table size within MAX_TABLE_SIZE limit",
+        status: "skip",
+    },
+    {
+        id: "GC-04",
+        description: "Description length within MAX_DESCRIPTION_LENGTH",
+        status: "skip",
+    },
+    {
+        id: "GC-05",
+        description: "Binding scene identified (one of 8 scenes) or Standalone",
+        status: "skip",
+    },
+    {
+        id: "GC-06",
+        description: "All query nodes reference valid GUARDQUERY instructions",
+        status: "skip",
+    },
+    {
+        id: "GC-07",
+        description: "All witness nodes use valid WitnessType (100-108)",
+        status: "skip",
+    },
+    {
+        id: "GC-08",
+        description: "No circular rely chain in root tree",
+        status: "skip",
+    },
+    {
+        id: "GC-09",
+        description: "Type compatibility verified for all equal/compare nodes",
+        status: "skip",
+    },
+    {
+        id: "GC-10",
+        description: "Context nodes (Signer/Clock/Guard) used with correct semantics",
+        status: "skip",
+    },
+    {
+        id: "GC-11",
+        description: "Submission data (b_submission=true) marked as Type3 with forgery risk evaluated",
+        status: "skip",
+    },
+    {
+        id: "GC-12",
+        description: "Immutability acknowledged — Guard CANNOT be modified after creation",
+        status: "skip",
+    },
+];
+export const GUARD_CONFIRMATION_QUESTIONS = [
+    {
+        id: "QG1",
+        question: "Have you verified that the Guard's validation rule matches your business intent (e.g., 'customer must have paid' rather than 'customer must NOT have paid')?",
+        expected_response: "yes",
+        blocking: true,
+        explanation: "Inverted logic is the #1 cause of Guard failures. The rule_sentence in your puzzle should match the on-chain enforcement direction.",
+    },
+    {
+        id: "QG2",
+        question: "Have you confirmed that all Type3 (b_submission=true) data sources are forgery-resistant (submitted by trusted callers, not user-supplied)?",
+        expected_response: "yes",
+        blocking: true,
+        explanation: "Type3 data is the most common attack vector. If users can submit arbitrary values, the Guard is bypassable.",
+    },
+    {
+        id: "QG3",
+        question: "Have you tested the Guard on testnet with gen_passport to verify it returns the expected pass/fail result for both valid and invalid inputs?",
+        expected_response: "yes",
+        blocking: true,
+        explanation: "gen_passport is the only way to test Guard evaluation without binding it. Skipping this risks publishing a broken Guard.",
+    },
+    {
+        id: "QG4",
+        question: "Is the binding target (Service/Machine/Reward/etc.) already published or planned in the same deployment batch?",
+        expected_response: "yes",
+        blocking: false,
+        explanation: "Guard can be created standalone, but its binding field expects an existing object. Plan creation order accordingly.",
+    },
+    {
+        id: "QG5",
+        question: "Are you aware that this Guard is IMMUTABLE after creation and cannot be modified (only a new version can be created)?",
+        expected_response: "yes",
+        blocking: true,
+        explanation: "Unlike Machine (which allows permission changes), Guard has NO update entry point. Review the rule twice before confirming.",
+    },
+    {
+        id: "QG6",
+        question: "Have you reviewed the game-theory implications — does this Guard favor one stakeholder (customer/provider/arbitrator) unfairly?",
+        expected_response: "no",
+        blocking: false,
+        explanation: "Answer 'no' = no unfair advantage. If 'yes', review the game_theory risk rules in guard-risk.ts and adjust.",
+    },
+];
+export const GUARD_CONFIRM_VERSION = "1.0.0";
+export function runGuardConfirmGate(input) {
+    const decision_record = {
+        final_decision: "blocked",
+        timestamp: new Date().toISOString(),
+        layers_passed: [],
+    };
+    const checklist_result = runStaticChecklist(input.guard_json, input.existing_lint_issues);
+    if (!checklist_result.passed) {
+        return {
+            status: "blocked_checklist",
+            checklist_result,
+            decision_record: {
+                ...decision_record,
+                final_reason: `Layer 1 failed: ${checklist_result.failed_items.map(i => i.id).join(", ")}`,
+            },
+        };
+    }
+    decision_record.layers_passed.push("checklist");
+    let risk_result;
+    if (input.existing_risk_assessment) {
+        risk_result = adaptRiskAssessment(input.existing_risk_assessment);
+    }
+    else {
+        const guard_data = input.guard_json.root;
+        const assessment = assessGuardRisks({
+            table: guard_data?.table ?? [],
+            root: input.guard_json.root,
+            rely: guard_data?.rely,
+        });
+        risk_result = adaptRiskAssessment(assessment);
+    }
+    if (risk_result.recommendation === "do_not_publish") {
+        return {
+            status: "blocked_risk",
+            checklist_result,
+            risk_result,
+            decision_record: {
+                ...decision_record,
+                final_reason: `Layer 2 blocked: ${risk_result.blocking_risks.length} CRITICAL risks`,
+            },
+        };
+    }
+    decision_record.layers_passed.push("risk");
+    if (!input.skip_user_confirmation) {
+        const confirmation_text = generateGuardConfirmationText(input.guard_json, checklist_result, risk_result);
+        const user_confirmation = processUserConfirmation(input.user_responses);
+        if (!user_confirmation.approved) {
+            return {
+                status: "blocked_user",
+                checklist_result,
+                risk_result,
+                confirmation_text,
+                user_confirmation,
+                decision_record: {
+                    ...decision_record,
+                    final_reason: `Layer 3 declined: ${user_confirmation.declined_reason ?? "no reason given"}`,
+                },
+            };
+        }
+        decision_record.layers_passed.push("user");
+        if (!input.skip_environment) {
+            const environment_result = verifyGuardEnvironment(input.guard_json);
+            if (!environment_result.testnet_tested || !environment_result.rely_chain_resolvable) {
+                return {
+                    status: "blocked_environment",
+                    checklist_result,
+                    risk_result,
+                    user_confirmation,
+                    environment_result,
+                    decision_record: {
+                        ...decision_record,
+                        final_reason: `Layer 4 failed: environment issues`,
+                    },
+                };
+            }
+            decision_record.layers_passed.push("environment");
+        }
+        return {
+            status: "approved",
+            checklist_result,
+            risk_result,
+            user_confirmation,
+            confirmation_text: generateGuardConfirmationText(input.guard_json, checklist_result, risk_result),
+            decision_record: {
+                ...decision_record,
+                final_decision: "approved",
+            },
+        };
+    }
+    decision_record.layers_passed.push("user");
+    return {
+        status: "approved",
+        checklist_result,
+        risk_result,
+        decision_record: {
+            ...decision_record,
+            final_decision: "approved",
+        },
+    };
+}
+function runStaticChecklist(guard_json, existing_issues) {
+    const checked_items = [];
+    const failed_items = [];
+    const warnings = [];
+    for (const template of GUARD_PUBLISH_CHECKLIST) {
+        const item = { ...template, status: "skip" };
+        try {
+            const result = evaluateChecklistItem(item.id, guard_json, existing_issues);
+            item.status = result.status;
+            item.detail = result.detail;
+            if (result.status === "fail")
+                failed_items.push(item);
+            else if (result.status === "warning")
+                warnings.push(item);
+        }
+        catch (err) {
+            item.status = "warning";
+            item.detail = `Check error: ${err.message}`;
+            warnings.push(item);
+        }
+        checked_items.push(item);
+    }
+    return {
+        passed: failed_items.length === 0,
+        checked_items,
+        failed_items,
+        warnings,
+    };
+}
+function evaluateChecklistItem(id, guard_json, existing_issues) {
+    const root = guard_json.root;
+    switch (id) {
+        case "GC-01":
+            if (!root || !root.type)
+                return { status: "fail", detail: "Root node missing or has no type" };
+            return { status: "pass" };
+        case "GC-02":
+        case "GC-03":
+        case "GC-04": {
+            if (existing_issues && existing_issues.length > 0) {
+                const related = existing_issues.find(i => i.path?.includes("table") || i.path?.includes("description"));
+                if (related)
+                    return { status: "fail", detail: related.message };
+            }
+            return { status: "pass", detail: "Validated by SDK validateGuardData" };
+        }
+        case "GC-05": {
+            if (guard_json.binding_scene_id) {
+                const scene = GUARD_SCENES.find(s => s.id === guard_json.binding_scene_id);
+                if (scene)
+                    return { status: "pass", detail: `Scene: ${scene.id}` };
+                return { status: "warning", detail: `Scene ID "${guard_json.binding_scene_id}" not found in ledger` };
+            }
+            return { status: "warning", detail: "No binding scene identified — verify Standalone intent" };
+        }
+        case "GC-06":
+        case "GC-07":
+        case "GC-08":
+        case "GC-09":
+        case "GC-10":
+        case "GC-11":
+            if (existing_issues && existing_issues.some(i => i.path?.includes("query") || i.path?.includes("witness"))) {
+                return { status: "fail", detail: "SDK validation flagged query/witness issues" };
+            }
+            return { status: "pass", detail: "Delegated to guard-lint.ts" };
+        case "GC-12":
+            return { status: "pass", detail: "Immutability noted — Guard cannot be modified after creation" };
+        default:
+            return { status: "skip" };
+    }
+}
+function adaptRiskAssessment(assessment) {
+    const blocking_risks = [];
+    const warning_risks = [];
+    for (const risk of assessment.risks ?? []) {
+        if (risk.level === "critical")
+            blocking_risks.push(risk.id);
+        else if (risk.level === "high")
+            warning_risks.push(risk.id);
+    }
+    let recommendation = "publish";
+    if (blocking_risks.length > 0)
+        recommendation = "do_not_publish";
+    else if (warning_risks.length > 2)
+        recommendation = "fix_first";
+    return {
+        overall_risk_level: assessment.overall_risk,
+        blocking_risks,
+        warning_risks,
+        recommendation,
+    };
+}
+function processUserConfirmation(responses) {
+    const questions_asked = GUARD_CONFIRMATION_QUESTIONS;
+    if (!responses || responses.length === 0) {
+        return {
+            questions_asked,
+            user_responses: [],
+            approved: false,
+            declined_reason: "No user responses provided",
+            timestamp: new Date().toISOString(),
+        };
+    }
+    const blocking_questions = questions_asked.filter(q => q.blocking);
+    for (const q of blocking_questions) {
+        const response = responses.find(r => r.question_id === q.id);
+        if (!response) {
+            return {
+                questions_asked,
+                user_responses: responses,
+                approved: false,
+                declined_reason: `Blocking question ${q.id} not answered`,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        if (q.expected_response === "yes" && response.response !== "yes") {
+            return {
+                questions_asked,
+                user_responses: responses,
+                approved: false,
+                declined_reason: `${q.id} expected 'yes', got '${response.response}'`,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        if (q.expected_response === "no" && response.response !== "no") {
+            return {
+                questions_asked,
+                user_responses: responses,
+                approved: false,
+                declined_reason: `${q.id} expected 'no', got '${response.response}'`,
+                timestamp: new Date().toISOString(),
+            };
+        }
+    }
+    return {
+        questions_asked,
+        user_responses: responses,
+        approved: true,
+        timestamp: new Date().toISOString(),
+    };
+}
+function generateGuardConfirmationText(guard_json, checklist, risk) {
+    const lines = [];
+    lines.push("═══════════════════════════════════════════════════════════");
+    lines.push("  GUARD PUBLISH CONFIRMATION");
+    lines.push("═══════════════════════════════════════════════════════════");
+    lines.push(`Name: ${guard_json.name ?? "(unnamed)"}`);
+    lines.push(`Description: ${guard_json.description ?? "(none)"}`);
+    lines.push(`Binding Scene: ${guard_json.binding_scene_id ?? "Standalone"}`);
+    lines.push("");
+    lines.push("─ Layer 1: Static Checklist ─────────────────────────────");
+    lines.push(`Result: ${checklist.passed ? "✅ PASS" : "❌ FAIL"}`);
+    lines.push(`Items: ${checklist.checked_items.length} checked, ${checklist.failed_items.length} failed, ${checklist.warnings.length} warnings`);
+    lines.push("");
+    lines.push("─ Layer 2: Risk Assessment ──────────────────────────────");
+    lines.push(`Overall: ${risk.overall_risk_level.toUpperCase()}`);
+    lines.push(`Blocking: ${risk.blocking_risks.length} | Warning: ${risk.warning_risks.length}`);
+    lines.push(`Recommendation: ${risk.recommendation}`);
+    lines.push("");
+    lines.push("⚠️  CRITICAL REMINDER: Guard is IMMUTABLE after creation.");
+    lines.push("    There is NO update path. If the rule is wrong, you must");
+    lines.push("    create a NEW Guard and rebind the host object.");
+    lines.push("");
+    lines.push("Please review the above and confirm publication.");
+    lines.push("═══════════════════════════════════════════════════════════");
+    return lines.join("\n");
+}
+function verifyGuardEnvironment(guard_json) {
+    const warnings = [];
+    if (!guard_json.binding_target) {
+        warnings.push("No binding target specified — Guard will be Standalone (verify intent)");
+    }
+    return {
+        testnet_tested: false,
+        binding_target_exists: !!guard_json.binding_target,
+        rely_chain_resolvable: true,
+        passport_generated_successfully: false,
+        warnings,
+    };
+}
+export function progressiveGuardCheck(guard_json) {
+    const checklist = runStaticChecklist(guard_json);
+    if (!checklist.passed) {
+        return { layer: "checklist", result: checklist };
+    }
+    const guard_data = guard_json.root;
+    const assessment = assessGuardRisks({
+        table: guard_data?.table ?? [],
+        root: guard_json.root,
+        rely: guard_data?.rely,
+    });
+    const risk = adaptRiskAssessment(assessment);
+    if (risk.recommendation === "do_not_publish") {
+        return { layer: "risk", result: risk };
+    }
+    return { layer: "none", result: null };
+}

package/dist/knowledge/guard-context.d.ts

@@ -0,0 +1,56 @@
+import { type GuardScene } from "./guard-ledger.js";
+import { type GuardTemplate } from "./guard-templates.js";
+import { type SemanticToSchemaRule } from "./guard-translation.js";
+import { type RiskRule, type GuardRiskAssessment, type GuardStakeholder } from "./guard-risk.js";
+import { type GuardPuzzle, type PuzzleCompleteness } from "./guard-puzzle.js";
+import { GUARD_PUBLISH_CHECKLIST, GUARD_CONFIRMATION_QUESTIONS, type GuardJsonForConfirm } from "./guard-confirm.js";
+export declare const GUARD_CONTEXT_VERSION = "1.0.0";
+export type GuardInjectionMode = "initial_design" | "mid_design_review" | "pre_publish" | "post_publish_binding" | "stakeholder_review" | "binding_check";
+export type GuardStakeholderPerspective = GuardStakeholder | "system";
+export interface GuardContextBundle {
+    version: string;
+    mode: GuardInjectionMode;
+    stakeholder_perspective?: GuardStakeholderPerspective;
+    matched_scene?: GuardScene;
+    matched_template?: GuardTemplate;
+    matched_pattern?: SemanticToSchemaRule;
+    puzzle_state?: GuardPuzzle;
+    puzzle_completeness?: PuzzleCompleteness;
+    relevant_risks: RiskRule[];
+    risk_assessment?: GuardRiskAssessment;
+    relevant_checklist: typeof GUARD_PUBLISH_CHECKLIST;
+    relevant_questions: typeof GUARD_CONFIRMATION_QUESTIONS;
+    cross_object_refs: GuardCrossObjectRef[];
+    onchain_constraints: GuardOnchainConstraint[];
+    rendering_hints: GuardRenderingHints;
+}
+export interface GuardCrossObjectRef {
+    object: "Machine" | "Service" | "Reward" | "Arbitration" | "Repository" | "Progress" | "Demand";
+    field: string;
+    scene_id: string;
+    description: string;
+}
+export interface GuardOnchainConstraint {
+    name: string;
+    value: string | number | bigint;
+    description: string;
+}
+export interface GuardRenderingHints {
+    include_puzzle_template: boolean;
+    include_risk_details: boolean;
+    include_questions: boolean;
+    include_immutability_warning: boolean;
+    max_length: number;
+}
+export interface BuildGuardContextInput {
+    mode: GuardInjectionMode;
+    intent?: string;
+    guard_json?: GuardJsonForConfirm;
+    stakeholder?: GuardStakeholderPerspective;
+    target_host_object?: GuardScene["host_object"];
+    target_binding_field?: string;
+    max_length?: number;
+}
+export declare function buildGuardContext(input: BuildGuardContextInput): GuardContextBundle;
+export declare function buildPromptFromGuardContext(bundle: GuardContextBundle): string;
+export declare function getGuardContextSummary(bundle: GuardContextBundle): string;