@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/passport-confirm.js

@@ -0,0 +1,531 @@
+import { MAX_GUARD_COUNT_PASSPORT, MAX_SUBMISSION_SIZE_PASSPORT, PASSPORT_ERROR_CODES, } from "./passport-ledger.js";
+import { assessPassportRisks, } from "./passport-risk.js";
+export const PASSPORT_CONFIRMATION_RULES = {
+    creation: [
+        {
+            id: "C-PASS-01",
+            check: "Confirm Clock object is accessible (new requires Clock argument)",
+            severity: "HIGH",
+            action: "block",
+            layer: "creation",
+        },
+        {
+            id: "C-PASS-02",
+            check: "Confirm current transaction context is valid (tx_hash will bind to this transaction)",
+            severity: "CRITICAL",
+            action: "block",
+            layer: "creation",
+        },
+    ],
+    operation: [
+        {
+            id: "C-PASS-03",
+            check: "guard_add: confirm has_verified=false (E_HAS_VERIFIED)",
+            severity: "CRITICAL",
+            action: "block",
+            related_error: "E_HAS_VERIFIED (4)",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-04",
+            check: "guard_add: confirm tx_hash matches current transaction (E_DIGEST_NOT_MATCH)",
+            severity: "CRITICAL",
+            action: "block",
+            related_error: "E_DIGEST_NOT_MATCH (11)",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-05",
+            check: "guard_add: confirm depended-on Guards already added (E_RELIES_GUARD_NOT_ADDED)",
+            severity: "HIGH",
+            action: "block",
+            related_error: "E_RELIES_GUARD_NOT_ADDED (2)",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-06",
+            check: "guard_add: warn Guard count approaching MAX_GUARD_COUNT=20 limit",
+            severity: "MEDIUM",
+            action: "warn",
+            related_error: "E_GUARD_COUNT_EXCEEDED (1)",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-07",
+            check: "guard_add: warn impack Guard failure will cause overall result=false",
+            severity: "HIGH",
+            action: "warn",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-08",
+            check: "guard_add: warn submission serialized size must be ≤ 256 bytes",
+            severity: "MEDIUM",
+            action: "warn",
+            related_error: "E_SUBMISSION_SIZE_EXCEEDED (3)",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-09",
+            check: "verify: warn this is a one-time operation; after verify, configuration cannot be modified",
+            severity: "HIGH",
+            action: "confirm_twice",
+            related_error: "E_HAS_VERIFIED (4)",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-10",
+            check: "verify: confirm at least 1 impack Guard exists (E_IMPACK_GUARD_NOT_FOUND)",
+            severity: "CRITICAL",
+            action: "block",
+            related_error: "E_IMPACK_GUARD_NOT_FOUND (9)",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-11",
+            check: "guard_clear: warn this will clear all Guards (allowed before verify)",
+            severity: "MEDIUM",
+            action: "confirm_twice",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-12",
+            check: "freezen: warn after freezing, Passport is permanently retained and cannot be destroyed",
+            severity: "MEDIUM",
+            action: "confirm_twice",
+            layer: "operation",
+        },
+        {
+            id: "C-PASS-13",
+            check: "destroy: warn Passport cannot be recovered after destruction (must be before freeze)",
+            severity: "HIGH",
+            action: "confirm_twice",
+            layer: "operation",
+        },
+    ],
+    consistency: [
+        {
+            id: "C-PASS-14",
+            check: "Confirm Passport object is not frozen (no operations allowed after freeze)",
+            severity: "HIGH",
+            action: "block",
+            layer: "consistency",
+        },
+        {
+            id: "C-PASS-15",
+            check: "Confirm referenced Guard objects have not been deleted",
+            severity: "HIGH",
+            action: "block",
+            layer: "consistency",
+        },
+        {
+            id: "C-PASS-16",
+            check: "Confirm has_verified=true when querying result (E_NOT_VERIFIED)",
+            severity: "HIGH",
+            action: "block",
+            related_error: "E_NOT_VERIFIED (5)",
+            layer: "consistency",
+        },
+        {
+            id: "C-PASS-17",
+            check: "Confirm tx_hash matches current transaction when querying result (E_TX_NOT_MATCH)",
+            severity: "CRITICAL",
+            action: "block",
+            related_error: "E_TX_NOT_MATCH (8)",
+            layer: "consistency",
+        },
+        {
+            id: "C-PASS-18",
+            check: "Info: relies dependencies (avoid circular dependencies)",
+            severity: "INFO",
+            action: "info",
+            layer: "consistency",
+        },
+        {
+            id: "C-PASS-19",
+            check: "Warn: non-impack Guard result does not affect final result",
+            severity: "INFO",
+            action: "info",
+            layer: "consistency",
+        },
+        {
+            id: "C-PASS-20",
+            check: "Info: Passport emits no events; status must be queried actively",
+            severity: "INFO",
+            action: "info",
+            layer: "consistency",
+        },
+    ],
+};
+export function preCheckPassportCreation(input) {
+    const errors = [];
+    const warnings = [];
+    const requiresConfirmation = [];
+    if (!input.clock) {
+        errors.push("Clock object is required for Passport creation (C-PASS-01, passport::new requires Clock argument)");
+    }
+    if (!input.txDigest) {
+        errors.push("Valid transaction context required — tx_hash will bind to this transaction (C-PASS-02)");
+    }
+    return {
+        errors,
+        warnings,
+        requiresConfirmation,
+        canProceed: errors.length === 0,
+    };
+}
+export function preCheckPassportOperation(input) {
+    const errors = [];
+    const warnings = [];
+    const requiresConfirmation = [];
+    const { passport, operation, guardObjects } = input;
+    switch (operation.type) {
+        case "guard_add": {
+            if (passport.has_verified) {
+                errors.push(`Passport already verified, cannot add guard (C-PASS-03, E_HAS_VERIFIED=${PASSPORT_ERROR_CODES.E_HAS_VERIFIED})`);
+                break;
+            }
+            warnings.push(`tx_hash must match current transaction (C-PASS-04, E_DIGEST_NOT_MATCH=${PASSPORT_ERROR_CODES.E_DIGEST_NOT_MATCH})`);
+            const guardObj = guardObjects.get(operation.guard);
+            if (guardObj?.relies && guardObj.relies.length > 0) {
+                for (const relyAddr of guardObj.relies) {
+                    const relyAdded = passport.info.some(g => g.guard === relyAddr);
+                    if (!relyAdded) {
+                        errors.push(`Dependency Guard ${relyAddr} not added yet (C-PASS-05, E_RELIES_GUARD_NOT_ADDED=${PASSPORT_ERROR_CODES.E_RELIES_GUARD_NOT_ADDED})`);
+                    }
+                }
+            }
+            if (passport.info.length >= MAX_GUARD_COUNT_PASSPORT) {
+                errors.push(`Guard count ${passport.info.length} >= MAX_GUARD_COUNT_PASSPORT=${MAX_GUARD_COUNT_PASSPORT} (C-PASS-06, E_GUARD_COUNT_EXCEEDED=${PASSPORT_ERROR_CODES.E_GUARD_COUNT_EXCEEDED})`);
+            }
+            else if (passport.info.length >= MAX_GUARD_COUNT_PASSPORT - 5) {
+                warnings.push(`Guard count ${passport.info.length} approaching limit ${MAX_GUARD_COUNT_PASSPORT} (C-PASS-06)`);
+            }
+            if (operation.impack) {
+                warnings.push("impack=true Guard failure will cause overall result=false (C-PASS-07)");
+            }
+            if (operation.submission) {
+                const estimatedSize = estimateSubmissionSize(operation.submission);
+                if (estimatedSize > MAX_SUBMISSION_SIZE_PASSPORT) {
+                    errors.push(`Submission size ${estimatedSize} > MAX_SUBMISSION_SIZE_PASSPORT=${MAX_SUBMISSION_SIZE_PASSPORT} (C-PASS-08, E_SUBMISSION_SIZE_EXCEEDED=${PASSPORT_ERROR_CODES.E_SUBMISSION_SIZE_EXCEEDED})`);
+                }
+                else if (estimatedSize > MAX_SUBMISSION_SIZE_PASSPORT * 0.8) {
+                    warnings.push(`Submission size ${estimatedSize} approaching limit ${MAX_SUBMISSION_SIZE_PASSPORT} (C-PASS-08)`);
+                }
+            }
+            break;
+        }
+        case "verify": {
+            requiresConfirmation.push("WARNING: verify is ONE-TIME operation. After verify, guard configuration cannot be modified. Type 'CONFIRM' to proceed. (C-PASS-09)");
+            const hasImpack = passport.info.some(g => g.impack);
+            if (!hasImpack) {
+                errors.push(`No impack Guard found, verify will fail (C-PASS-10, E_IMPACK_GUARD_NOT_FOUND=${PASSPORT_ERROR_CODES.E_IMPACK_GUARD_NOT_FOUND})`);
+            }
+            break;
+        }
+        case "guard_clear": {
+            requiresConfirmation.push(`WARNING: guard_clear will remove all ${passport.info.length} guards. Type 'CONFIRM' to proceed. (C-PASS-11)`);
+            if (passport.has_verified) {
+                errors.push(`Passport already verified, cannot clear guards (C-PASS-11, E_HAS_VERIFIED=${PASSPORT_ERROR_CODES.E_HAS_VERIFIED})`);
+            }
+            break;
+        }
+        case "freezen": {
+            requiresConfirmation.push("WARNING: freezen will PERMANENTLY freeze the Passport. It cannot be destroyed after freezing. Type 'CONFIRM' to proceed. (C-PASS-12)");
+            break;
+        }
+        case "destroy": {
+            requiresConfirmation.push("WARNING: destroy will delete the Passport permanently. This must be done BEFORE freezing. Type 'CONFIRM' to proceed. (C-PASS-13)");
+            break;
+        }
+        case "result_query":
+        case "result_for_guard":
+        case "result_for_permission": {
+            if (!passport.has_verified) {
+                errors.push(`result query requires has_verified=true (C-PASS-16, E_NOT_VERIFIED=${PASSPORT_ERROR_CODES.E_NOT_VERIFIED})`);
+            }
+            warnings.push(`result query requires tx_hash match current transaction (C-PASS-17, E_TX_NOT_MATCH=${PASSPORT_ERROR_CODES.E_TX_NOT_MATCH})`);
+            if (operation.type === "result_for_guard") {
+                const guardInfo = passport.info.find(g => g.guard === operation.guard);
+                if (!guardInfo) {
+                    errors.push(`Guard ${operation.guard} not found in Passport (C-PASS-15)`);
+                }
+                else if (!guardInfo.impack) {
+                    errors.push(`Guard ${operation.guard} is not impack, result_for_guard will abort (C-PASS-10, E_NOT_IMPACK_GUARD=${PASSPORT_ERROR_CODES.E_NOT_IMPACK_GUARD})`);
+                }
+            }
+            break;
+        }
+        case "submission_get": {
+            break;
+        }
+    }
+    return {
+        errors,
+        warnings,
+        requiresConfirmation,
+        canProceed: errors.length === 0,
+    };
+}
+export function checkPassportStateConsistency(input) {
+    const errors = [];
+    const warnings = [];
+    const { passport, guardObjects, isFrozen } = input;
+    if (isFrozen) {
+        errors.push("Passport is frozen (immutable), no write operations permitted (C-PASS-14)");
+    }
+    for (const g of passport.info) {
+        if (!guardObjects.has(g.guard)) {
+            warnings.push(`Guard ${g.guard} not found, verification may fail (C-PASS-15)`);
+        }
+    }
+    if (!passport.has_verified) {
+        warnings.push("Passport not yet verified — result queries will fail (C-PASS-16, E_NOT_VERIFIED)");
+    }
+    for (const g of passport.info) {
+        const guardObj = guardObjects.get(g.guard);
+        if (guardObj?.relies && guardObj.relies.length > 0) {
+            const logic = guardObj.relies_logic_and === false ? "OR" : "AND";
+            warnings.push(`Guard ${g.guard} relies on ${guardObj.relies.length} guards (${logic} logic) (C-PASS-18)`);
+        }
+    }
+    const nonImpack = passport.info.filter(g => !g.impack);
+    if (nonImpack.length > 0) {
+        warnings.push(`${nonImpack.length} non-impack guards will not affect final result (C-PASS-19)`);
+    }
+    warnings.push("Passport does not emit events, must query object state directly (C-PASS-20)");
+    return {
+        errors,
+        warnings,
+        requiresConfirmation: [],
+        canProceed: errors.length === 0,
+    };
+}
+export const PASSPORT_CONFIRM_VERSION = "1.0.0";
+export function runPassportConfirmGate(input) {
+    const layersPassed = [];
+    const layersFailed = [];
+    let riskAssessment;
+    if (input.creation_input) {
+        const creationResult = preCheckPassportCreation(input.creation_input);
+        if (!creationResult.canProceed) {
+            layersFailed.push("L1_creation");
+            return {
+                status: "blocked_creation",
+                creation_result: creationResult,
+                risk_assessment: riskAssessment,
+                confirmation_text: generateConfirmationText(input, creationResult),
+                block_reason: `Creation blocked: ${creationResult.errors.join("; ")}`,
+                decision_record: {
+                    timestamp: new Date().toISOString(),
+                    gate_version: PASSPORT_CONFIRM_VERSION,
+                    final_status: "blocked_creation",
+                    layers_passed: layersPassed,
+                    layers_failed: layersFailed,
+                },
+            };
+        }
+        layersPassed.push("L1_creation");
+    }
+    if (input.operation_input) {
+        const opResult = preCheckPassportOperation(input.operation_input);
+        if (!opResult.canProceed) {
+            layersFailed.push("L2_operation");
+            return {
+                status: "blocked_operation",
+                operation_result: opResult,
+                risk_assessment: riskAssessment,
+                confirmation_text: generateConfirmationText(input, undefined, opResult),
+                block_reason: `Operation blocked: ${opResult.errors.join("; ")}`,
+                decision_record: {
+                    timestamp: new Date().toISOString(),
+                    gate_version: PASSPORT_CONFIRM_VERSION,
+                    final_status: "blocked_operation",
+                    layers_passed: layersPassed,
+                    layers_failed: layersFailed,
+                },
+            };
+        }
+        if (!input.skip_user_confirmation && opResult.requiresConfirmation.length > 0) {
+            layersFailed.push("L2_operation_pending_confirmation");
+            return {
+                status: "pending_confirmation",
+                operation_result: opResult,
+                risk_assessment: riskAssessment,
+                confirmation_text: generateConfirmationText(input, undefined, opResult),
+                block_reason: `User confirmation required: ${opResult.requiresConfirmation.length} item(s)`,
+                decision_record: {
+                    timestamp: new Date().toISOString(),
+                    gate_version: PASSPORT_CONFIRM_VERSION,
+                    final_status: "pending_confirmation",
+                    layers_passed: layersPassed,
+                    layers_failed: layersFailed,
+                },
+            };
+        }
+        layersPassed.push("L2_operation");
+    }
+    if (input.consistency_input) {
+        const consResult = checkPassportStateConsistency(input.consistency_input);
+        if (!consResult.canProceed) {
+            layersFailed.push("L3_consistency");
+            return {
+                status: "blocked_consistency",
+                consistency_result: consResult,
+                risk_assessment: riskAssessment,
+                confirmation_text: generateConfirmationText(input, undefined, undefined, consResult),
+                block_reason: `Consistency blocked: ${consResult.errors.join("; ")}`,
+                decision_record: {
+                    timestamp: new Date().toISOString(),
+                    gate_version: PASSPORT_CONFIRM_VERSION,
+                    final_status: "blocked_consistency",
+                    layers_passed: layersPassed,
+                    layers_failed: layersFailed,
+                },
+            };
+        }
+        layersPassed.push("L3_consistency");
+    }
+    if (!input.skip_risk_assessment && input.operation_input) {
+        const riskCtx = {
+            object: input.operation_input.passport.object,
+            has_verified: input.operation_input.passport.has_verified,
+            guard_count: input.operation_input.passport.info.length,
+            has_impack_guard: input.operation_input.passport.info.some(g => g.impack),
+            operation_type: input.operation_input.operation.type === "guard_add" ? "guard_add"
+                : input.operation_input.operation.type === "verify" ? "verify"
+                    : input.operation_input.operation.type === "freezen" ? "freezen"
+                        : input.operation_input.operation.type === "destroy" ? "destroy"
+                            : "use",
+            is_frozen: input.consistency_input?.isFrozen ?? false,
+            matched_scenario: input.scenario,
+            constants_synced: true,
+            knowledge_files_present: true,
+        };
+        riskAssessment = assessPassportRisks(riskCtx);
+    }
+    return {
+        status: "approved",
+        creation_result: input.creation_input ? preCheckPassportCreation(input.creation_input) : undefined,
+        operation_result: input.operation_input ? preCheckPassportOperation(input.operation_input) : undefined,
+        consistency_result: input.consistency_input ? checkPassportStateConsistency(input.consistency_input) : undefined,
+        risk_assessment: riskAssessment,
+        confirmation_text: generateConfirmationText(input),
+        decision_record: {
+            timestamp: new Date().toISOString(),
+            gate_version: PASSPORT_CONFIRM_VERSION,
+            final_status: "approved",
+            layers_passed: layersPassed,
+            layers_failed: layersFailed,
+        },
+    };
+}
+function generateConfirmationText(input, creation, operation, consistency) {
+    const lines = [];
+    lines.push("═══ Passport Confirmation ═══");
+    lines.push("");
+    if (input.scenario) {
+        lines.push(`Scenario: ${input.scenario.name}`);
+        lines.push(`Consumer: ${input.scenario.consumer_object} (${input.scenario.sdk_entry})`);
+        lines.push(`Purpose: ${input.scenario.passport_purpose}`);
+        lines.push("");
+    }
+    if (creation) {
+        lines.push("─ Layer 1: Creation ──────────────");
+        if (creation.errors.length > 0) {
+            for (const e of creation.errors)
+                lines.push(`  ✗ ${e}`);
+        }
+        else {
+            lines.push("  ✓ All creation checks passed");
+        }
+        lines.push("");
+    }
+    if (operation) {
+        lines.push("─ Layer 2: Operation ──────────────");
+        if (operation.errors.length > 0) {
+            for (const e of operation.errors)
+                lines.push(`  ✗ ${e}`);
+        }
+        if (operation.warnings.length > 0) {
+            for (const w of operation.warnings)
+                lines.push(`  ⚠ ${w}`);
+        }
+        if (operation.requiresConfirmation.length > 0) {
+            for (const c of operation.requiresConfirmation)
+                lines.push(`  ? ${c}`);
+        }
+        if (operation.errors.length === 0 && operation.warnings.length === 0 && operation.requiresConfirmation.length === 0) {
+            lines.push("  ✓ All operation checks passed");
+        }
+        lines.push("");
+    }
+    if (consistency) {
+        lines.push("─ Layer 3: Consistency ──────────────");
+        if (consistency.errors.length > 0) {
+            for (const e of consistency.errors)
+                lines.push(`  ✗ ${e}`);
+        }
+        if (consistency.warnings.length > 0) {
+            for (const w of consistency.warnings)
+                lines.push(`  ⚠ ${w}`);
+        }
+        if (consistency.errors.length === 0 && consistency.warnings.length === 0) {
+            lines.push("  ✓ All consistency checks passed");
+        }
+        lines.push("");
+    }
+    lines.push("─ Error Code Reference ──────────────");
+    lines.push(`  E_GUARD_COUNT_EXCEEDED=${PASSPORT_ERROR_CODES.E_GUARD_COUNT_EXCEEDED}, E_RELIES_GUARD_NOT_ADDED=${PASSPORT_ERROR_CODES.E_RELIES_GUARD_NOT_ADDED}, E_SUBMISSION_SIZE_EXCEEDED=${PASSPORT_ERROR_CODES.E_SUBMISSION_SIZE_EXCEEDED}`);
+    lines.push(`  E_HAS_VERIFIED=${PASSPORT_ERROR_CODES.E_HAS_VERIFIED}, E_NOT_VERIFIED=${PASSPORT_ERROR_CODES.E_NOT_VERIFIED}, E_NOT_IMPACK_GUARD=${PASSPORT_ERROR_CODES.E_NOT_IMPACK_GUARD}`);
+    lines.push(`  E_VERIFY_FAILED=${PASSPORT_ERROR_CODES.E_VERIFY_FAILED}, E_TX_NOT_MATCH=${PASSPORT_ERROR_CODES.E_TX_NOT_MATCH}, E_IMPACK_GUARD_NOT_FOUND=${PASSPORT_ERROR_CODES.E_IMPACK_GUARD_NOT_FOUND}`);
+    lines.push(`  E_SUBMISSION_NOT_FOUND=${PASSPORT_ERROR_CODES.E_SUBMISSION_NOT_FOUND}, E_DIGEST_NOT_MATCH=${PASSPORT_ERROR_CODES.E_DIGEST_NOT_MATCH}`);
+    lines.push("");
+    return lines.join("\n");
+}
+export function estimateSubmissionSize(submission) {
+    let total = 0;
+    for (const item of submission) {
+        total += 1;
+        switch (item.value_type) {
+            case "bool":
+                total += 1;
+                break;
+            case "u8":
+                total += 1;
+                break;
+            case "u64":
+                total += 8;
+                break;
+            case "address":
+                total += 32;
+                break;
+            case "string": {
+                const len = typeof item.value === "string" ? item.value.length : 0;
+                total += 1 + len;
+                break;
+            }
+            case "vector<u8>": {
+                const len = Array.isArray(item.value) ? item.value.length : 0;
+                total += 1 + len;
+                break;
+            }
+            default:
+                total += 64;
+        }
+    }
+    return total;
+}
+export function getAllConfirmationRules() {
+    return [
+        ...PASSPORT_CONFIRMATION_RULES.creation,
+        ...PASSPORT_CONFIRMATION_RULES.operation,
+        ...PASSPORT_CONFIRMATION_RULES.consistency,
+    ];
+}
+export function getConfirmationRulesByLayer(layer) {
+    return PASSPORT_CONFIRMATION_RULES[layer];
+}
+export function getConfirmationRuleById(id) {
+    return getAllConfirmationRules().find(r => r.id === id);
+}

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

@@ -0,0 +1,59 @@
+import { PASSPORT_SCENARIOS, MAX_GUARD_COUNT_PASSPORT, MAX_SUBMISSION_SIZE_PASSPORT, PASSPORT_ERROR_CODES, findScenarioById, inferScenarioFromIntent, getAllScenarios, type PassportScenario, type PassportConsumerObject } from "./passport-ledger.js";
+import { PASSPORT_TEMPLATES, PASSPORT_TEMPLATES_VERSION, getTemplateById, getTemplatesByScenario, suggestTemplateForScenario, type PassportTemplate } from "./passport-templates.js";
+import { SEMANTIC_TO_SCHEMA_RULES, PASSPORT_CONSTRAINT_RULES, matchSemanticPattern, explainPassport, passportJsonToSemantic, semanticToPassportJson, explainField, explainOp, explainImpack, explainReliesLogic, explainError, getConstraintsByCategory, type SemanticToSchemaRule, type PassportConstraintRule, type PassportCallData } from "./passport-translation.js";
+import { getAllRiskRules, assessPassportRisks, PASSPORT_RISK_VERSION, type PassportRiskRule, type PassportRiskAssessment, type PassportStakeholder } from "./passport-risk.js";
+import { initPuzzleFromIntent, checkPuzzleCompleteness, validateConstraints, buildPassportPuzzle, buildResultPuzzle, type PassportPuzzle, type PassportPuzzleCompleteness } from "./passport-puzzle.js";
+import { PASSPORT_CONFIRMATION_RULES, PASSPORT_CONFIRM_VERSION, preCheckPassportCreation, preCheckPassportOperation, checkPassportStateConsistency, runPassportConfirmGate, type PassportConfirmationRule, type ObjectPassport } from "./passport-confirm.js";
+export declare const PASSPORT_CONTEXT_VERSION = "1.0.0";
+export type PassportInjectionMode = "initial_design" | "mid_design_review" | "pre_verify" | "post_verify_use" | "stakeholder_review" | "scenario_match";
+export type PassportStakeholderPerspective = PassportStakeholder | "system";
+export interface PassportContextBundle {
+    version: string;
+    mode: PassportInjectionMode;
+    stakeholder_perspective?: PassportStakeholderPerspective;
+    matched_scenario?: PassportScenario;
+    matched_template?: PassportTemplate;
+    matched_pattern?: SemanticToSchemaRule;
+    puzzle_state?: PassportPuzzle;
+    puzzle_completeness?: PassportPuzzleCompleteness;
+    relevant_risks: PassportRiskRule[];
+    risk_assessment?: PassportRiskAssessment;
+    relevant_checklist: PassportConfirmationRule[];
+    cross_object_refs: PassportCrossObjectRef[];
+    onchain_constraints: PassportOnchainConstraint[];
+    rendering_hints: PassportRenderingHints;
+}
+export interface PassportCrossObjectRef {
+    object: PassportConsumerObject | "Guard" | "Clock" | "Transaction";
+    field: string;
+    scenario_id: string;
+    description: string;
+}
+export interface PassportOnchainConstraint {
+    name: string;
+    value: string | number;
+    description: string;
+}
+export interface PassportRenderingHints {
+    include_puzzle_template: boolean;
+    include_risk_details: boolean;
+    include_tx_hash_warning: boolean;
+    include_one_time_verify_warning: boolean;
+    include_impack_warning: boolean;
+    include_relies_warning: boolean;
+    max_length: number;
+}
+export interface BuildPassportContextInput {
+    mode: PassportInjectionMode;
+    intent?: string;
+    passport_state?: ObjectPassport;
+    submission_call?: PassportCallData;
+    stakeholder?: PassportStakeholderPerspective;
+    target_consumer?: PassportConsumerObject;
+    max_length?: number;
+}
+export declare function buildPassportContext(input: BuildPassportContextInput): PassportContextBundle;
+export declare const getPassportContext: typeof buildPassportContext;
+export declare function buildPromptFromPassportContext(bundle: PassportContextBundle): string;
+export declare function getPassportContextSummary(bundle: PassportContextBundle): string;
+export { PASSPORT_SCENARIOS, MAX_GUARD_COUNT_PASSPORT, MAX_SUBMISSION_SIZE_PASSPORT, PASSPORT_ERROR_CODES, findScenarioById, inferScenarioFromIntent, getAllScenarios, PASSPORT_TEMPLATES, getTemplateById, getTemplatesByScenario, suggestTemplateForScenario, SEMANTIC_TO_SCHEMA_RULES, PASSPORT_CONSTRAINT_RULES, matchSemanticPattern, explainPassport, passportJsonToSemantic, semanticToPassportJson, explainField, explainOp, explainImpack, explainReliesLogic, explainError, getConstraintsByCategory, getAllRiskRules, assessPassportRisks, initPuzzleFromIntent, checkPuzzleCompleteness, validateConstraints, buildPassportPuzzle, buildResultPuzzle, PASSPORT_CONFIRMATION_RULES, preCheckPassportCreation, preCheckPassportOperation, checkPassportStateConsistency, runPassportConfirmGate, PASSPORT_RISK_VERSION, PASSPORT_CONFIRM_VERSION, PASSPORT_TEMPLATES_VERSION, type PassportScenario, type PassportTemplate, type SemanticToSchemaRule, type PassportConstraintRule, type PassportRiskRule, type PassportRiskAssessment, type PassportPuzzle, type PassportPuzzleCompleteness, type PassportConfirmationRule, type ObjectPassport, type PassportCallData, };