@crediolabs/policy-synth 0.1.8 → 0.1.10

package/dist/adapters/interpreter/adapter.js

@@ -307,6 +307,10 @@ function lowerSelector(s) {
     switch (s.kind) {
         case 'arg':
             return { kind: 'call_arg', index: s.argIndex };
+        case 'arg_len':
+            return { kind: 'call_arg_len', index: s.argIndex };
+        case 'arg_field':
+            return { kind: 'call_arg_field', index: s.argIndex, element: s.element, field: s.field };
         case 'amount':
             return { kind: 'amount', token: s.token };
         case 'window_spent':
@@ -329,13 +333,15 @@ function lowerSelector(s) {
  *  selector kind to the matching `literal_*` kind. The IR compare value is a
  *  raw string (i128-safe); the selector kind fixes the canonical wire type:
  *    - arg       -> IR scalarType (set by the recorder/parser)
+ *    - arg_len   -> u32 (vec length is a small non-negative integer)
+ *    - arg_field -> IR scalarType (the field's recorded type)
  *    - amount    -> i128 (canonical Stellar token amount encoding)
  *    - window_spent -> i128 (canonical amount encoding)
  *    - oracle_price  -> i128 (canonical price encoding)
  *    - invocation_count -> u32 (counts are small non-negative integers)
  *    - now / valid_until -> u64 (unix timestamps in seconds) */
 function literalFromIRCompare(c) {
-    const scalarType = c.selector.kind === 'arg' ? c.selector.scalarType : literalScalarForSelector(c.selector.kind);
+    const scalarType = selectorScalarType(c.selector);
     return literalFromScalar(c.value, scalarType);
 }
 function literalScalarForSelector(kind) {
@@ -345,14 +351,16 @@ function literalScalarForSelector(kind) {
         case 'oracle_price':
             return 'i128';
         case 'invocation_count':
+        case 'arg_len':
             return 'u32';
         case 'now':
         case 'valid_until':
             return 'u64';
         case 'arg':
+        case 'arg_field':
         case 'calldata':
         case 'value':
-            // arg -> caller handles scalarType; calldata/value -> unreachable (Path-B).
+            // arg / arg_field -> caller handles scalarType; calldata/value -> unreachable (Path-B).
             return 'i128';
     }
 }
@@ -380,10 +388,12 @@ function literalFromScalar(value, scalarType) {
 /** Scalar type of an IRSelector for the purpose of building literal leaves
  *  (the right-hand side of `eq` / elements of an `in` haystack / elements of
  *  a `literal_vec`). Mirrors `literalScalarForSelector` for OZ extensions and
- *  uses the selector's own `scalarType` for `arg` selectors. */
+ *  uses the selector's own `scalarType` for `arg` and `arg_field` selectors. */
 function selectorScalarType(selector) {
     if (selector.kind === 'arg')
         return selector.scalarType;
+    if (selector.kind === 'arg_field')
+        return selector.scalarType;
     return literalScalarForSelector(selector.kind);
 }
 /** Walk a condition tree and throw if any oracle_price leaf is found anywhere
@@ -457,6 +467,10 @@ function describeCondition(cond) {
                     return `per-call amount comparison on ${s.token}`;
                 case 'arg':
                     return `argument comparison on arg ${s.argIndex}`;
+                case 'arg_len':
+                    return `vec length comparison on arg ${s.argIndex}`;
+                case 'arg_field':
+                    return `map field comparison on arg ${s.argIndex}.${s.field}`;
                 case 'calldata':
                     return 'EVM calldata comparison';
                 case 'value':
@@ -472,6 +486,10 @@ function describeSelector(s) {
     switch (s.kind) {
         case 'arg':
             return `arg ${s.argIndex}`;
+        case 'arg_len':
+            return `arg_len(${s.argIndex})`;
+        case 'arg_field':
+            return `arg_field(${s.argIndex}, ${s.element}, ${s.field})`;
         case 'amount':
             return `amount(${s.token})`;
         case 'window_spent':

package/dist/adapters/oz/adapter.js

@@ -229,6 +229,10 @@ function describeCondition(cond) {
                     return `per-call amount comparison on ${s.token} (predicate DSL)`;
                 case 'arg':
                     return `argument comparison on arg ${s.argIndex} (predicate DSL)`;
+                case 'arg_len':
+                    return `vec length comparison on arg ${s.argIndex} (predicate DSL)`;
+                case 'arg_field':
+                    return `map field comparison on arg ${s.argIndex}.${s.field} (predicate DSL)`;
                 case 'calldata':
                     return 'EVM calldata comparison (predicate DSL)';
                 case 'value':
@@ -244,6 +248,10 @@ function describeSelector(s) {
     switch (s.kind) {
         case 'arg':
             return `arg ${s.argIndex}`;
+        case 'arg_len':
+            return `arg_len(${s.argIndex})`;
+        case 'arg_field':
+            return `arg_field(${s.argIndex}, ${s.element}, ${s.field})`;
         case 'amount':
             return `amount(${s.token})`;
         case 'window_spent':

package/dist/ir/types.d.ts

@@ -14,6 +14,15 @@ export type IRSelector = {
     fieldIndex?: number;
     vecMode?: IRVecMode;
     scalarType: IRScalarType;
+} | {
+    kind: 'arg_len';
+    argIndex: number;
+} | {
+    kind: 'arg_field';
+    argIndex: number;
+    element: number;
+    field: string;
+    scalarType: IRScalarType;
 } | {
     kind: 'calldata';
     offset: number;

package/dist/predicate/encode.js

@@ -167,6 +167,15 @@ function encodeLeaf(leaf) {
             return xdr.ScVal.scvVec([symbol('call_fn')]);
         case 'call_arg':
             return xdr.ScVal.scvVec([symbol('call_arg'), xdr.ScVal.scvU32(leaf.index)]);
+        case 'call_arg_len':
+            return xdr.ScVal.scvVec([symbol('call_arg_len'), xdr.ScVal.scvU32(leaf.index)]);
+        case 'call_arg_field':
+            return xdr.ScVal.scvVec([
+                symbol('call_arg_field'),
+                xdr.ScVal.scvU32(leaf.index),
+                xdr.ScVal.scvU32(leaf.element),
+                xdr.ScVal.scvSymbol(leaf.field),
+            ]);
         case 'amount':
             return xdr.ScVal.scvVec([symbol('amount'), scvAddressFromStrkey(leaf.token)]);
         case 'window_spent':

package/dist/review-card/builder.js

@@ -138,6 +138,36 @@ function renderComparison(node) {
     if (left.kind === 'call_arg' && node.op === 'eq' && right.kind === 'literal_vec') {
         return `Path must be exactly [${right.elements.map(renderVecElement).join(', ')}]`;
     }
+    // eq(call_arg_len[i], literal_u32) -> Length of arg[i] is K
+    // Binds the OUTER vec length so a caller cannot append an element to
+    // defeat a per-element pin. Rendered as a single readable line so the
+    // review card surfaces the implicit "no new elements" guarantee.
+    if (left.kind === 'call_arg_len' && node.op === 'eq' && right.kind === 'literal_u32') {
+        return `Length of arg[${left.index}] is ${right.value}`;
+    }
+    // eq/lte(call_arg_field[i, el, field], <literal>) -> arg[i] element[el].field = <value>
+    // The structured-argument bind pins a scalar field inside a vec element.
+    // For lt/gt/lte/gte the line reads "OP <value>" so the comparison kind
+    // is visible; eq reads "= <value>".
+    if (left.kind === 'call_arg_field') {
+        const head = `arg[${left.index}] element[${left.element}].${left.field}`;
+        const sep = node.op === 'eq' ? '=' : comparisonOpText(node.op);
+        if (right.kind === 'literal_address')
+            return `${head} ${sep} ${right.value}`;
+        if (right.kind === 'literal_symbol')
+            return `${head} ${sep} ${right.value}`;
+        if (right.kind === 'literal_bytes')
+            return `${head} ${sep} ${right.value}`;
+        if (right.kind === 'literal_u64')
+            return `${head} ${sep} ${right.value}`;
+        if (right.kind === 'literal_i128')
+            return `${head} ${sep} ${right.value}`;
+        if (right.kind === 'literal_u32')
+            return `${head} ${sep} ${right.value}`;
+        if (right.kind === 'literal_vec') {
+            return `${head} ${sep} [${right.elements.map(renderVecElement).join(', ')}]`;
+        }
+    }
     // invocation_count_in_window <= N -> Invocations <= N per <window> seconds
     if (left.kind === 'invocation_count_in_window' && right.kind === 'literal_u32') {
         return `Invocations <= ${right.value} per ${left.windowSecs} seconds`;
@@ -184,6 +214,8 @@ function renderVecElement(leaf) {
         case 'call_contract':
         case 'call_fn':
         case 'call_arg':
+        case 'call_arg_len':
+        case 'call_arg_field':
         case 'amount':
         case 'window_spent':
         case 'now':

package/dist/review-card/cross-check.js

@@ -67,6 +67,44 @@ function pushComparison(left, right, op, out) {
         out.push(`Path must be exactly [${right.elements.map(renderVecElement).join(', ')}]`);
         return;
     }
+    if (left.kind === 'call_arg_len' && op === 'eq' && right.kind === 'literal_u32') {
+        out.push(`Length of arg[${left.index}] is ${right.value}`);
+        return;
+    }
+    // call_arg_field: must mirror the builder's templates byte-for-byte so
+    // the cross-check can assert a faithful summary.
+    if (left.kind === 'call_arg_field') {
+        const head = `arg[${left.index}] element[${left.element}].${left.field}`;
+        const sep = op === 'eq' ? '=' : comparisonOpText(op);
+        if (right.kind === 'literal_address') {
+            out.push(`${head} ${sep} ${right.value}`);
+            return;
+        }
+        if (right.kind === 'literal_symbol') {
+            out.push(`${head} ${sep} ${right.value}`);
+            return;
+        }
+        if (right.kind === 'literal_bytes') {
+            out.push(`${head} ${sep} ${right.value}`);
+            return;
+        }
+        if (right.kind === 'literal_u64') {
+            out.push(`${head} ${sep} ${right.value}`);
+            return;
+        }
+        if (right.kind === 'literal_i128') {
+            out.push(`${head} ${sep} ${right.value}`);
+            return;
+        }
+        if (right.kind === 'literal_u32') {
+            out.push(`${head} ${sep} ${right.value}`);
+            return;
+        }
+        if (right.kind === 'literal_vec') {
+            out.push(`${head} ${sep} [${right.elements.map(renderVecElement).join(', ')}]`);
+            return;
+        }
+    }
     if (left.kind === 'invocation_count_in_window' && right.kind === 'literal_u32') {
         out.push(`Invocations <= ${right.value} per ${left.windowSecs} seconds`);
         return;
@@ -105,6 +143,8 @@ function renderVecElement(leaf) {
         case 'call_contract':
         case 'call_fn':
         case 'call_arg':
+        case 'call_arg_len':
+        case 'call_arg_field':
         case 'amount':
         case 'window_spent':
         case 'now':

package/dist/run/index.d.ts

@@ -1,4 +1,5 @@
-import { type ErrorCode, type ProposedPolicy, type RecordedTransaction, type ToolError, type ToolResponse } from '../index.ts';
+import { type ErrorCode, type PredicateNode, type ProposedPolicy, type RecordedTransaction, type ToolError, type ToolResponse } from '../index.ts';
+import type { SimulationResult } from '../verify/envelope.ts';
 import { type RecordTransactionInput, type SynthesizePolicyInput } from './schemas.ts';
 export type { RecordTransactionInput, SynthesizePolicyInput } from './schemas.ts';
 export { ComposeUserResponsesSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OzAdapterConfigSchema, RecordedTransactionSchema, RecordTransactionInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, } from './schemas.ts';
@@ -28,7 +29,12 @@ export declare function runRecordTransaction(raw: unknown): Promise<ToolResponse
  *  `{ok:false, error}`, but a raw throw from the SDK (e.g. an unexpected
  *  XDR decode error in the adapter) would otherwise surface as
  *  "[object Object]" in the MCP transport. */
-export declare function runSynthesizePolicy(raw: unknown): Promise<ToolResponse<ProposedPolicy>>;
+export declare function runSynthesizePolicy(raw: unknown): Promise<ToolResponse<ProposedPolicy> & {
+    explain?: {
+        predicateTree: PredicateNode | null;
+        simulation: SimulationResult;
+    };
+}>;
 /** Build a canonical ToolError for a thrown exception caught by the tool
  *  envelope. The MCP SDK stringifies thrown objects as "[object Object]" by
  *  default, so we extract a string-friendly message and tag the original

package/dist/run/index.js

@@ -89,7 +89,7 @@ export async function runSynthesizePolicy(raw) {
             // Zod's optional fields widen to `T | undefined`, which the core's
             // exact-optional MandateSpec rejects; the schema already validated the
             // shape, so assert it (same pattern as the recordedTx cast below).
-            return await synthesizeFromMandate(input.mandate, ozConfig);
+            return await synthesizeFromMandate(input.mandate, ozConfig, input.explain === true ? { explain: true } : {});
         }
         // recording source
         const recorded = input.recordedTx;
@@ -100,6 +100,7 @@ export async function runSynthesizePolicy(raw) {
                 ? { confidenceOverride: input.confidenceOverride }
                 : {}),
             ...(input.interpreter !== undefined ? { interpreter: input.interpreter } : {}),
+            ...(input.explain === true ? { explain: true } : {}),
         }, ozConfig);
     }
     catch (e) {

package/dist/run/schemas.d.ts

@@ -648,6 +648,7 @@ export declare const SynthesizePolicyMandateInputSchema: z.ZodObject<{
             weighted_threshold: string;
         };
     }>>;
+    explain: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     source: "mandate";
     mandate: {
@@ -676,6 +677,7 @@ export declare const SynthesizePolicyMandateInputSchema: z.ZodObject<{
             weighted_threshold: string;
         };
     } | undefined;
+    explain?: boolean | undefined;
 }, {
     source: "mandate";
     mandate: {
@@ -704,6 +706,7 @@ export declare const SynthesizePolicyMandateInputSchema: z.ZodObject<{
             weighted_threshold: string;
         };
     } | undefined;
+    explain?: boolean | undefined;
 }>;
 /** Interpreter opt-in for the recording path. Present -> constraints OZ cannot
  *  express (per-method scoping, invocation-count windows, oracle bounds, exact
@@ -1085,6 +1088,7 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
             weighted_threshold: string;
         };
     }>>;
+    explain: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     network: "mainnet" | "testnet";
     source: "recording";
@@ -1149,6 +1153,7 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
             weighted_threshold: string;
         };
     } | undefined;
+    explain?: boolean | undefined;
 }, {
     network: "mainnet" | "testnet";
     source: "recording";
@@ -1213,6 +1218,7 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
             weighted_threshold: string;
         };
     } | undefined;
+    explain?: boolean | undefined;
 }>;
 export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"source", [z.ZodObject<{
     source: z.ZodLiteral<"mandate">;
@@ -1334,6 +1340,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             weighted_threshold: string;
         };
     }>>;
+    explain: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     source: "mandate";
     mandate: {
@@ -1362,6 +1369,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             weighted_threshold: string;
         };
     } | undefined;
+    explain?: boolean | undefined;
 }, {
     source: "mandate";
     mandate: {
@@ -1390,6 +1398,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             weighted_threshold: string;
         };
     } | undefined;
+    explain?: boolean | undefined;
 }>, z.ZodObject<{
     source: z.ZodLiteral<"recording">;
     recordedTx: z.ZodObject<{
@@ -1736,6 +1745,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             weighted_threshold: string;
         };
     }>>;
+    explain: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     network: "mainnet" | "testnet";
     source: "recording";
@@ -1800,6 +1810,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             weighted_threshold: string;
         };
     } | undefined;
+    explain?: boolean | undefined;
 }, {
     network: "mainnet" | "testnet";
     source: "recording";
@@ -1864,6 +1875,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             weighted_threshold: string;
         };
     } | undefined;
+    explain?: boolean | undefined;
 }>]>;
 export type SynthesizePolicyInput = z.infer<typeof SynthesizePolicyInputSchema>;
 export declare const ToolErrorSchema: z.ZodObject<{

package/dist/run/schemas.js

@@ -175,6 +175,11 @@ export const SynthesizePolicyMandateInputSchema = z.object({
     source: z.literal('mandate'),
     mandate: MandateSpecSchema,
     ozConfig: OzAdapterConfigSchema.optional(),
+    // --explain opt-in. When true, the orchestrator attaches the
+    // in-memory predicate tree (null for the mandate path) + a minimal
+    // honest SimulationResult to the success envelope. Absent or false
+    // -> the success envelope is unchanged (byte-identical to today).
+    explain: z.boolean().optional(),
 });
 /** Interpreter opt-in for the recording path. Present -> constraints OZ cannot
  *  express (per-method scoping, invocation-count windows, oracle bounds, exact
@@ -200,6 +205,15 @@ export const SynthesizePolicyRecordingInputSchema = z.object({
     confidenceOverride: z.object({ threshold: z.number().min(0).max(1) }).optional(),
     interpreter: InterpreterOptionsSchema.optional(),
     ozConfig: OzAdapterConfigSchema.optional(),
+    // --explain opt-in. When true, the orchestrator attaches the
+    // in-memory PredicateNode + the corresponding SimulationResult
+    // (real one from the self-verify pipeline when the interpreter is
+    // engaged, minimal honest value otherwise) to the success envelope.
+    // Absent or false -> the success envelope is unchanged (byte-identical
+    // to today). The flag is ADDITIVE: the existing ProposedPolicy fields
+    // (encodedPredicate, predicateHash, etc.) are never altered by enabling
+    // explain.
+    explain: z.boolean().optional(),
 });
 export const SynthesizePolicyInputSchema = z.discriminatedUnion('source', [
     SynthesizePolicyMandateInputSchema,

package/dist/synth/compose-from-recording.js

@@ -276,6 +276,95 @@ function appendProtocolSpecificConstraints(ozConstraints, interpreterConstraints
             }
         }
     }
+    // Blend `submit` ONLY (not `claim`, whose vec arg is a vec<u32> of
+    // reserve_token_ids - no map fields to bind). The `requests` vec
+    // (call_arg[3]) is a vec<Request{ address, amount, request_type }>. Each
+    // Request is the per-reserve action selector - 0 Supply, 1 Withdraw,
+    // 2 SupplyCollateral, 3 WithdrawCollateral, 4 Borrow, 5 Repay, 6-9
+    // liquidation/auction fills. Pinning only one element is unsafe: a caller
+    // can append a second element with a different action (WithdrawCollateral
+    // -> Borrow on a different asset, any amount, then auction fills). Length
+    // + per-element pinning is total; a quantifier over elements is not. If we
+    // cannot emit BOTH, we surface AMBIGUITY rather than emit a partial bind.
+    if (protocol.protocol === 'blend' && protocol.fn === 'submit' && interpreterEnabled) {
+        const requestsArg = topLevel.args[3];
+        if (requestsArg && requestsArg.type === 'vec') {
+            const elements = requestsArg.value;
+            interpreterConstraints.push({
+                op: 'compare',
+                compare: {
+                    selector: { kind: 'arg_len', argIndex: 3 },
+                    operator: 'eq',
+                    value: String(elements.length),
+                },
+            });
+            for (let i = 0; i < elements.length; i++) {
+                const element = elements[i];
+                if (!element || element.type !== 'map')
+                    continue;
+                const fields = element.value;
+                const fieldValue = (name, scalarType) => {
+                    const entry = fields.find((e) => e.key === name);
+                    if (!entry)
+                        return null;
+                    if (entry.val.type === 'address' && scalarType === 'address')
+                        return entry.val.value;
+                    if (entry.val.type === 'i128' && scalarType === 'i128')
+                        return entry.val.value;
+                    if (entry.val.type === 'u32' && scalarType === 'u32')
+                        return entry.val.value;
+                    return null;
+                };
+                const address = fieldValue('address', 'address');
+                const amount = fieldValue('amount', 'i128');
+                const requestType = fieldValue('request_type', 'u32');
+                if (address === null || amount === null || requestType === null)
+                    continue;
+                interpreterConstraints.push({
+                    op: 'compare',
+                    compare: {
+                        selector: {
+                            kind: 'arg_field',
+                            argIndex: 3,
+                            element: i,
+                            field: 'request_type',
+                            scalarType: 'u32',
+                        },
+                        operator: 'eq',
+                        value: requestType,
+                    },
+                });
+                interpreterConstraints.push({
+                    op: 'compare',
+                    compare: {
+                        selector: {
+                            kind: 'arg_field',
+                            argIndex: 3,
+                            element: i,
+                            field: 'address',
+                            scalarType: 'address',
+                        },
+                        operator: 'eq',
+                        value: address,
+                    },
+                });
+                interpreterConstraints.push({
+                    op: 'compare',
+                    compare: {
+                        selector: {
+                            kind: 'arg_field',
+                            argIndex: 3,
+                            element: i,
+                            field: 'amount',
+                            scalarType: 'i128',
+                        },
+                        operator: 'lte',
+                        value: amount,
+                    },
+                });
+            }
+        }
+    }
     // SoroSwap: the recorded hop path -> eq_seq on the path arg (call_arg[2]).
     // The interpreter adapter is the ONLY way to express an exact ordered
     // sequence (OZ built-ins cannot). Element order is preserved verbatim.

package/dist/synth/deny-cases.js

@@ -16,6 +16,15 @@ const ADJACENT_ASSETS = [
 // them as FINDINGS against the already-emitted policy.
 const OVERPERMISSIVE_DIMENSIONS = ['argument_reorder'];
 // The 15 dimensions the synth pipeline uses for self-verify and minimise.
+// Phase 1 grammar extension: `vec_append` and `map_field_flip` are listed below
+// alongside the existing dimensions so the per-element binds emitted for
+// Blend `submit` (call_arg_len + 3 call_arg_field per element) survive
+// minimise. Without these, no deny case exercises the new leaves and the
+// minimise pass drops them as "redundant" - reopening the element-append
+// hole they were added to close. Both dimensions are no-ops for any fixture
+// whose predicate has no `call_arg_len` / `call_arg_field` leaves (the
+// generator short-circuits on leaf-kind), so they cannot make production
+// synthesis refuse for fixtures that do not exercise the new grammar.
 const ORIGINAL_DIMENSIONS = [
     'amount',
     'asset',
@@ -32,6 +41,8 @@ const ORIGINAL_DIMENSIONS = [
     'oracle_deviation_exceeded',
     'oracle_paused',
     'soroswap_allowed_path',
+    'vec_append',
+    'map_field_flip',
 ];
 export { ORIGINAL_DIMENSIONS, OVERPERMISSIVE_DIMENSIONS };
 /** Build deterministic model-evaluated alternatives without mutating the intended call.
@@ -191,7 +202,9 @@ export function generateCases(predicate, permitCtx, dimensions) {
         hasConstrainedArg &&
         permitCtx.args.length >= 2 &&
         permitCtx.args[0]?.type === 'address' &&
-        permitCtx.args[1]?.type === 'address') {
+        permitCtx.args[1]?.type === 'address' &&
+        permitCtx.args[0].value !==
+            permitCtx.args[1].value) {
         const ctx = cloneContext(permitCtx);
         // Guard above guarantees args[0] and args[1] exist and are address-typed.
         const a0 = ctx.args[0];
@@ -200,6 +213,59 @@ export function generateCases(predicate, permitCtx, dimensions) {
         ctx.args[1] = a0;
         denies.push({ dimension: 'argument_reorder', ctx });
     }
+    // --- map_field_flip: flip a bound map field to a different valid value of
+    // the same type. Mirrors argument_reorder: OPT-IN only, never ORIGINAL.
+    // Targets each `call_arg_field` leaf and produces a ctx whose vec element
+    // has a different value of the recorded field (different request_type,
+    // different amount, different address). The blend-submit case uses this
+    // to detect a missing request_type pin. ---
+    if (!dimensions || dimensions.includes('map_field_flip')) {
+        for (const comparison of facts.comparisons) {
+            const sel = comparison.left;
+            if (sel.kind !== 'call_arg_field')
+                continue;
+            const arg = permitCtx.args[sel.index];
+            if (!arg || arg.type !== 'vec')
+                continue;
+            const element = arg.value[sel.element];
+            if (!element || element.type !== 'map' || !Array.isArray(element.value))
+                continue;
+            const entry = element.value.find((e) => e.key === sel.field);
+            if (!entry)
+                continue;
+            const flipped = flipFieldValue(entry.val);
+            if (flipped === null)
+                continue;
+            const ctx = cloneContext(permitCtx);
+            const clonedVec = arg.value.map(cloneScVal);
+            const clonedElement = clonedVec[sel.element];
+            if (clonedElement?.type !== 'map' || !Array.isArray(clonedElement.value))
+                continue;
+            clonedElement.value = clonedElement.value.map((e) => e.key === sel.field ? { key: e.key, val: flipped } : e);
+            clonedVec[sel.element] = clonedElement;
+            ctx.args[sel.index] = { type: 'vec', value: clonedVec };
+            denies.push({ dimension: 'map_field_flip', ctx });
+        }
+    }
+    // --- vec_append: append a new element to a bound vec. Mirrors map_field_flip:
+    // OPT-IN only, never ORIGINAL. Targets every `call_arg_len` leaf; without the
+    // length pin a caller can append an extra element to defeat per-element binds. ---
+    if (!dimensions || dimensions.includes('vec_append')) {
+        for (const comparison of facts.comparisons) {
+            const sel = comparison.left;
+            if (sel.kind !== 'call_arg_len')
+                continue;
+            const arg = permitCtx.args[sel.index];
+            if (!arg || arg.type !== 'vec')
+                continue;
+            const ctx = cloneContext(permitCtx);
+            ctx.args[sel.index] = {
+                type: 'vec',
+                value: [...arg.value, { type: 'other', value: 'deny-case-vec-append' }],
+            };
+            denies.push({ dimension: 'vec_append', ctx });
+        }
+    }
     // Version mismatch, malformed predicates, master authorization, and nonce replay are install-time checks and are intentionally omitted from model-evaluated cases.
     return { permit: cloneContext(permitCtx), denies };
 }
@@ -431,3 +497,25 @@ function cloneDepthError(value) {
     err.depthContext = value.type;
     throw err;
 }
+/** Build a value of the SAME ScVal type that differs from the recorded one,
+ *  used by the `map_field_flip` mutation to defeat a per-element pin without
+ *  changing the wire type (a type/arity change is rejected by host dispatch
+ *  before Policy::enforce, so it is not the predicate's job). Returns null
+ *  when the ScVal type has no obvious different value (e.g. opaque/other). */
+function flipFieldValue(val) {
+    switch (val.type) {
+        case 'address': {
+            const a = 'GBFKRGJYZXLTDEI36ZCQEIM225NMOCR2VDBOIHJTXJ54FEFFVL2FKALE';
+            const b = 'GD6XSMQJ47EHHJOWXQOND5YDVZC37JWZJHYHBKE6QJFSLLJ5KQXM5QS5';
+            return { type: 'address', value: val.value === a ? b : a };
+        }
+        case 'i128':
+        case 'u64':
+        case 'u32':
+            return { type: val.type, value: String(BigInt(val.value) + 1n) };
+        case 'symbol':
+            return { type: 'symbol', value: `${val.value}x` };
+        default:
+            return null;
+    }
+}