@crediolabs/policy-synth 0.4.0 → 0.5.0

package/dist/review-card/builder.js

@@ -80,15 +80,31 @@ function walkPredicate(node, visit) {
             for (const child of node.children)
                 walkPredicate(child, visit);
             return;
+        // NOT descended into. Every line the card emits reads as a requirement,
+        // and `and` is what makes that true. Listing an `or`'s branches as
+        // separate lines would state the opposite of what the policy means, so
+        // the whole disjunction is rendered as ONE line instead.
+        case 'or':
+            visit(node);
+            return;
         case 'in':
             visit(node);
             return;
         case 'eq':
+        case 'lt':
         case 'lte':
+        case 'gt':
+        case 'gte':
             visit(node);
             return;
     }
 }
+/** Argument index of a `call_arg` leaf, for the scaled-comparison line. Any
+ *  other leaf renders as its kind so the line stays readable rather than
+ *  claiming an index that does not exist. */
+function leftArgLabel(leaf) {
+    return leaf.kind === 'call_arg' ? String(leaf.index) : `<${leaf.kind}>`;
+}
 /** Render ONE constraint sentence for ONE interpreter predicate node. The
  *  shape of the output is pinned by Task 7b so the test suite can assert
  *  byte-for-byte equality. Returns `null` when the node is a structural
@@ -97,14 +113,38 @@ function renderConstraint(node) {
     switch (node.op) {
         case 'and':
             return null;
+        case 'or': {
+            // One line for the whole disjunction. If any branch is a shape the
+            // card cannot render, the entire line is withheld rather than shown
+            // with a branch missing - a disjunction with a branch dropped reads
+            // as STRICTER than it is, which is the dangerous direction.
+            const parts = node.children.map(renderConstraint);
+            if (parts.some((p) => p === null))
+                return null;
+            return `Either: ${parts.join(' OR ')}`;
+        }
         case 'eq':
+        case 'lt':
         case 'lte':
+        case 'gt':
+        case 'gte':
             return renderComparison(node);
         case 'in':
             return renderMembership(node);
     }
 }
 function renderComparison(node) {
+    // The slippage floor: OP(call_arg[out], call_arg_scaled(in, num, den)).
+    // Rendered explicitly because the human approving the signature has to see
+    // that the bound is a RATIO of another argument, not a fixed amount.
+    if (node.right.kind === 'call_arg_scaled') {
+        const s = node.right;
+        return `arg[${leftArgLabel(node.left)}] ${comparisonOpText(node.op)} arg[${s.index}] * ${s.num}/${s.den}`;
+    }
+    if (node.left.kind === 'call_arg_scaled') {
+        const s = node.left;
+        return `arg[${s.index}] * ${s.num}/${s.den} ${comparisonOpText(node.op)} arg[${leftArgLabel(node.right)}]`;
+    }
     const left = node.left;
     const right = node.right;
     // eq(call_contract, literal_address) -> Contract must be <addr>

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

@@ -39,8 +39,30 @@ function collect(node, out) {
             for (const child of node.children)
                 collect(child, out);
             return;
+        // ONE line for the whole disjunction, mirroring the builder. Emitting a
+        // line per branch would claim every branch is required, which is the
+        // opposite of what `or` means. If any branch renders to nothing the whole
+        // line is withheld, again mirroring the builder - a disjunction missing a
+        // branch reads STRICTER than it is.
+        case 'or': {
+            const parts = [];
+            for (const child of node.children) {
+                const childOut = [];
+                collect(child, childOut);
+                if (childOut.length !== 1)
+                    return;
+                parts.push(childOut[0]);
+            }
+            if (parts.length === 0)
+                return;
+            out.push(`Either: ${parts.join(' OR ')}`);
+            return;
+        }
         case 'eq':
+        case 'lt':
         case 'lte':
+        case 'gt':
+        case 'gte':
             pushComparison(node.left, node.right, node.op, out);
             return;
         case 'in':
@@ -49,6 +71,18 @@ function collect(node, out) {
     }
 }
 function pushComparison(left, right, op, out) {
+    // Slippage floor, mirroring the builder. The human has to see that the
+    // bound is a RATIO of another argument, not a fixed amount.
+    if (right.kind === 'call_arg_scaled') {
+        const label = left.kind === 'call_arg' ? String(left.index) : `<${left.kind}>`;
+        out.push(`arg[${label}] ${comparisonOpText(op)} arg[${right.index}] * ${right.num}/${right.den}`);
+        return;
+    }
+    if (left.kind === 'call_arg_scaled') {
+        const label = right.kind === 'call_arg' ? String(right.index) : `<${right.kind}>`;
+        out.push(`arg[${left.index}] * ${left.num}/${left.den} ${comparisonOpText(op)} arg[${label}]`);
+        return;
+    }
     if (left.kind === 'call_contract' && op === 'eq' && right.kind === 'literal_address') {
         out.push(`Contract must be ${right.value}`);
         return;

package/dist/review-card/render-leaf.d.ts

@@ -1,4 +1,4 @@
 import type { PredicateLeaf } from '../types.ts';
 export declare function renderVecElement(leaf: PredicateLeaf): string;
 export declare function renderHaystackElement(leaf: PredicateLeaf): string;
-export declare function comparisonOpText(op: 'eq' | 'lte'): string;
+export declare function comparisonOpText(op: 'eq' | 'lt' | 'lte' | 'gt' | 'gte'): string;

package/dist/review-card/render-leaf.js

@@ -20,6 +20,7 @@ export function renderVecElement(leaf) {
         case 'call_arg':
         case 'call_arg_len':
         case 'call_arg_field':
+        case 'call_arg_scaled':
             return `<${leaf.kind}>`;
     }
 }
@@ -39,8 +40,14 @@ export function renderHaystackElement(leaf) {
 }
 export function comparisonOpText(op) {
     switch (op) {
+        case 'lt':
+            return '<';
         case 'lte':
             return '<=';
+        case 'gt':
+            return '>';
+        case 'gte':
+            return '>=';
         case 'eq':
             return '==';
     }

package/dist/run/index.js

@@ -22,6 +22,7 @@ import { declarePredicate, encodePredicate, recordTransaction, synthesizeFromRec
 import { findAuthorityOverlaps, } from "../install/authority-overlap.js";
 import { buildInstallPolicyXdr, buildRevokePolicyXdr, rpcClientFromServer, } from "../install/build-install-policy.js";
 import { getInterpreterInfo } from "../install/get-interpreter-info.js";
+import { accountRuleReaderFromServer, collectObservedRules } from "../install/read-account-rules.js";
 import { decodePredicate } from "../predicate/decode.js";
 import { evaluate, generateCases } from "../simulate/index.js";
 import { DeclarePolicyInputSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, NETWORK_PASSPHRASES, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_WASM_SHA256, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, VerifyPolicyInputSchema, } from "./schemas.js";
@@ -151,11 +152,18 @@ export async function runInstallPolicy(raw) {
             rpc: rpcClient,
             ...(input.baseFee !== undefined ? { baseFee: input.baseFee } : {}),
         });
-        // Cross-rule scan, when the caller supplied what else is on the account.
-        // ABSENT is reported as `null` rather than an empty list: "we did not
-        // look" and "we looked and found nothing" are different answers, and
-        // collapsing them would let a caller read silence as safety.
-        const authorityScan = input.existingRules === undefined
+        // Cross-rule scan. The caller may supply `existingRules` (useful offline,
+        // and for testing); otherwise the account is READ, so the answer describes
+        // what is actually installed rather than what the caller happened to
+        // mention.
+        //
+        // `null` means NOT CHECKED and is returned whenever the scan cannot be
+        // trusted to be complete - the read failed, or it stopped before
+        // accounting for every live rule. An empty list would say "checked,
+        // nothing found", and a partial scan that reported `[]` would be claiming
+        // a safety it never established.
+        const observed = await resolveExistingRules(input, network, expectedInterpreter);
+        const authorityScan = observed === null
             ? null
             : findAuthorityOverlaps({
                 intended: {
@@ -167,9 +175,7 @@ export async function runInstallPolicy(raw) {
                     signers: input.rule.signers,
                     predicate: decodePredicate(encodedPredicate),
                 },
-                // The schema types `predicate` loosely (it is the shared
-                // PredicateNodeSchema); the shape is already validated.
-                existing: input.existingRules,
+                existing: observed,
             });
         return { ok: true, data: { ...result, authorityScan } };
     }
@@ -320,6 +326,7 @@ export function runDeclarePolicy(raw) {
             ...(d.recipients !== undefined ? { recipients: d.recipients } : {}),
             ...(d.recipientArgIndex !== undefined ? { recipientArgIndex: d.recipientArgIndex } : {}),
             ...(d.allowZeroCap !== undefined ? { allowZeroCap: d.allowZeroCap } : {}),
+            ...(d.minOutputRatio !== undefined ? { minOutputRatio: d.minOutputRatio } : {}),
         });
         const { encodedPredicate, predicateHash } = encodePredicate(predicate);
         return { ok: true, data: { predicate, encodedPredicate, predicateHash, warnings } };
@@ -415,6 +422,42 @@ export async function runGetInterpreterInfo(raw) {
  *  network, falling back to the pinned RPC for the network. The caller
  *  has already been gated against the pinned URL elsewhere, so the
  *  fallback here only ever picks from a finite, audited pair. */
+/** The account's other context rules, or `null` when they could not be
+ *  established completely.
+ *
+ *  Caller-supplied `existingRules` win: they let the scan run offline, and a
+ *  caller who passes them has said what to compare against. Otherwise the
+ *  account is read over RPC.
+ *
+ *  Every failure path returns `null` rather than a short list. A read that
+ *  threw, or one that stopped before accounting for every live rule, has not
+ *  ruled anything out - and reporting `[]` there would turn "we could not
+ *  check" into "there is nothing to worry about". */
+async function resolveExistingRules(input, network, interpreterAddress) {
+    if (input.existingRules !== undefined) {
+        // The schema types `predicate` loosely (it is the shared
+        // PredicateNodeSchema); the shape is already validated.
+        return input.existingRules;
+    }
+    try {
+        const url = input.rpcUrl ?? RPC_URL_BY_NETWORK[network];
+        const server = new rpc.Server(url, { allowHttp: false });
+        const collected = await collectObservedRules({
+            reader: accountRuleReaderFromServer(server, NETWORK_PASSPHRASES[network]),
+            smartAccount: input.smartAccount,
+            interpreterAddress,
+        });
+        if (collected.incomplete)
+            return null;
+        return collected.rules;
+    }
+    catch {
+        // The install itself is unaffected: the scan is advisory, so a failed
+        // read must not block a policy the user asked for. It just cannot be
+        // reported as a clean scan.
+        return null;
+    }
+}
 function buildRpcClientFromInput(urlOverride, network) {
     const url = urlOverride ?? RPC_URL_BY_NETWORK[network];
     const passphrase = NETWORK_PASSPHRASES[network];

package/dist/run/schemas.d.ts

@@ -1559,6 +1559,7 @@ export declare const ObservedRuleSchema: z.ZodObject<{
         keyBytes: string;
     })[];
     id: number;
+    policyAddresses: string[];
     contextType: {
         kind: "default";
     } | {
@@ -1568,7 +1569,6 @@ export declare const ObservedRuleSchema: z.ZodObject<{
         kind: "create_contract";
         wasmHash: string;
     };
-    policyAddresses: string[];
     predicate?: unknown;
 }, {
     signers: ({
@@ -1580,6 +1580,7 @@ export declare const ObservedRuleSchema: z.ZodObject<{
         keyBytes: string;
     })[];
     id: number;
+    policyAddresses: string[];
     contextType: {
         kind: "default";
     } | {
@@ -1589,28 +1590,27 @@ export declare const ObservedRuleSchema: z.ZodObject<{
         kind: "create_contract";
         wasmHash: string;
     };
-    policyAddresses: string[];
     predicate?: unknown;
 }>;
 /** Pinned interpreter address (testnet).
  *  Single source for the MCP layer; do not embed elsewhere. */
-export declare const PINNED_INTERPRETER_TESTNET_ADDRESS = "CCL336TCK2Y5OFNRCMN2M3HVPBCEX4PW5H6EQ5VW5NPMXOCP4ESB5XR4";
-/** Pinned interpreter address (mainnet), redeployed 2026-08-22 from a reproducible build. The mainnet
+export declare const PINNED_INTERPRETER_TESTNET_ADDRESS = "CCBHVZ6HGGV7C4SNHCZ3S5665Z2WEMHTMBAEPO4XW6PKON464BEBANU5";
+/** Pinned interpreter address (mainnet), redeployed 2026-08-22 for grammar 4, from a reproducible build. The mainnet
  *  interpreter IS the binary exercised on testnet - both instances were created
  *  from the same uploaded wasm hash (see PINNED_INTERPRETER_WASM_SHA256), and
- *  both were read back with `grammar_version()` returning 3. The address differs
+ *  both were read back with `grammar_version()` returning 4. The address differs
  *  because instance ids are network-scoped. UNAUDITED at the time of writing.
  *
  *  These four constants move together or not at all. The grammar version and
  *  wasm hash are single values covering BOTH networks, so re-pinning one network
  *  alone would have the builder emit a version the other network refuses - with
  *  a green test run, since `grammar-version-parity.test.ts` would then pass. */
-export declare const PINNED_INTERPRETER_MAINNET_ADDRESS = "CBZXLSTQUITBFZHQH6XRXF3XIVRQR4RHRI64Q5WELS5KGY3ZKJPFWDPF";
+export declare const PINNED_INTERPRETER_MAINNET_ADDRESS = "CDN755TDYZM3ZQ5OXTJ6TIBUBWZV2KRI2BYJPBXD2MVWED4STT3VBN52";
 /** Pinned interpreter wasm sha256 (hex). */
-export declare const PINNED_INTERPRETER_WASM_SHA256 = "a2b36e8ac5a61caf3757af26aa79e83f2995b451099f44772383806a55fe3414";
+export declare const PINNED_INTERPRETER_WASM_SHA256 = "b5ba1e35ccf20cd8c13c3a2c3098bf337033a92bcaf475d63c03ddc0cba0fcae";
 /** The grammar version the interpreter enforces (matches SELF_VERSION in
  *  contracts/policy-interpreter/src/version.rs). */
-export declare const PINNED_INTERPRETER_GRAMMAR_VERSION = 3;
+export declare const PINNED_INTERPRETER_GRAMMAR_VERSION = 4;
 /** Default Soroban RPC for the install / revoke / info tools. The recorder
  *  keeps its own copy in record/rpc.ts because it hands back a fetcher rather
  *  than a Server; the two are deliberately different surfaces, so this is
@@ -1641,6 +1641,25 @@ export declare const DeclarePolicyInputSchema: z.ZodObject<{
     recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     recipientArgIndex: z.ZodOptional<z.ZodNumber>;
     allowZeroCap: z.ZodOptional<z.ZodBoolean>;
+    /** Minimum output as a ratio of the call's own input. num/den are decimal
+     *  STRINGS for the same reason maxAmount is: an i128 ratio does not
+     *  survive a JS number. */
+    minOutputRatio: z.ZodOptional<z.ZodObject<{
+        num: z.ZodString;
+        den: z.ZodString;
+        inputArgIndex: z.ZodNumber;
+        outputArgIndex: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    }, {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     fn: string;
     contract?: string | undefined;
@@ -1649,6 +1668,12 @@ export declare const DeclarePolicyInputSchema: z.ZodObject<{
     recipients?: string[] | undefined;
     recipientArgIndex?: number | undefined;
     allowZeroCap?: boolean | undefined;
+    minOutputRatio?: {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    } | undefined;
 }, {
     fn: string;
     contract?: string | undefined;
@@ -1657,6 +1682,12 @@ export declare const DeclarePolicyInputSchema: z.ZodObject<{
     recipients?: string[] | undefined;
     recipientArgIndex?: number | undefined;
     allowZeroCap?: boolean | undefined;
+    minOutputRatio?: {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    } | undefined;
 }>;
 export type DeclarePolicyInput = z.infer<typeof DeclarePolicyInputSchema>;
 export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
@@ -1726,6 +1757,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -1735,7 +1767,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }, {
         signers: ({
@@ -1747,6 +1778,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -1756,7 +1788,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }>, "many">>;
     /** The smart account contract address (C...) that will receive the rule. */
@@ -2153,6 +2184,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -2162,7 +2194,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }[] | undefined;
     rpcUrl?: string | undefined;
@@ -2212,6 +2243,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -2221,7 +2253,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }[] | undefined;
     rpcUrl?: string | undefined;
@@ -2271,6 +2302,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -2280,7 +2312,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }[] | undefined;
     rpcUrl?: string | undefined;
@@ -2330,6 +2361,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -2339,7 +2371,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }[] | undefined;
     rpcUrl?: string | undefined;

package/dist/run/schemas.js

@@ -177,6 +177,15 @@ export const PredicateLeafSchema = z.lazy(() => z.union([
         element: z.number().int().nonnegative(),
         field: z.string(),
     }),
+    // num/den are i128 decimal strings, matching `literal_i128`. The regex
+    // is the boundary guard; the ratio's SIGN is checked at encode, where
+    // the message can explain that a negative ratio inverts the comparison.
+    z.object({
+        kind: z.literal('call_arg_scaled'),
+        index: z.number().int().nonnegative(),
+        num: z.string().regex(/^-?[0-9]+$/),
+        den: z.string().regex(/^-?[0-9]+$/),
+    }),
     z.object({ kind: z.literal('literal_address'), value: z.string() }),
     z.object({ kind: z.literal('literal_i128'), value: z.string().regex(/^-?[0-9]+$/) }),
     z.object({ kind: z.literal('literal_symbol'), value: z.string() }),
@@ -195,16 +204,32 @@ export const PredicateLeafSchema = z.lazy(() => z.union([
  *  `and`; the lazy + annotation pattern keeps the recursion type-safe. */
 export const PredicateNodeSchema = z.lazy(() => z.union([
     z.object({ op: z.literal('and'), children: z.array(PredicateNodeSchema) }),
+    z.object({ op: z.literal('or'), children: z.array(PredicateNodeSchema) }),
     z.object({
         op: z.literal('eq'),
         left: PredicateLeafSchema,
         right: PredicateLeafSchema,
     }),
+    z.object({
+        op: z.literal('lt'),
+        left: PredicateLeafSchema,
+        right: PredicateLeafSchema,
+    }),
     z.object({
         op: z.literal('lte'),
         left: PredicateLeafSchema,
         right: PredicateLeafSchema,
     }),
+    z.object({
+        op: z.literal('gt'),
+        left: PredicateLeafSchema,
+        right: PredicateLeafSchema,
+    }),
+    z.object({
+        op: z.literal('gte'),
+        left: PredicateLeafSchema,
+        right: PredicateLeafSchema,
+    }),
     z.object({
         op: z.literal('in'),
         needle: PredicateLeafSchema,
@@ -300,23 +325,23 @@ const ContextRuleDraftSchema = z
 // existing four.
 /** Pinned interpreter address (testnet).
  *  Single source for the MCP layer; do not embed elsewhere. */
-export const PINNED_INTERPRETER_TESTNET_ADDRESS = 'CCL336TCK2Y5OFNRCMN2M3HVPBCEX4PW5H6EQ5VW5NPMXOCP4ESB5XR4';
-/** Pinned interpreter address (mainnet), redeployed 2026-08-22 from a reproducible build. The mainnet
+export const PINNED_INTERPRETER_TESTNET_ADDRESS = 'CCBHVZ6HGGV7C4SNHCZ3S5665Z2WEMHTMBAEPO4XW6PKON464BEBANU5';
+/** Pinned interpreter address (mainnet), redeployed 2026-08-22 for grammar 4, from a reproducible build. The mainnet
  *  interpreter IS the binary exercised on testnet - both instances were created
  *  from the same uploaded wasm hash (see PINNED_INTERPRETER_WASM_SHA256), and
- *  both were read back with `grammar_version()` returning 3. The address differs
+ *  both were read back with `grammar_version()` returning 4. The address differs
  *  because instance ids are network-scoped. UNAUDITED at the time of writing.
  *
  *  These four constants move together or not at all. The grammar version and
  *  wasm hash are single values covering BOTH networks, so re-pinning one network
  *  alone would have the builder emit a version the other network refuses - with
  *  a green test run, since `grammar-version-parity.test.ts` would then pass. */
-export const PINNED_INTERPRETER_MAINNET_ADDRESS = 'CBZXLSTQUITBFZHQH6XRXF3XIVRQR4RHRI64Q5WELS5KGY3ZKJPFWDPF';
+export const PINNED_INTERPRETER_MAINNET_ADDRESS = 'CDN755TDYZM3ZQ5OXTJ6TIBUBWZV2KRI2BYJPBXD2MVWED4STT3VBN52';
 /** Pinned interpreter wasm sha256 (hex). */
-export const PINNED_INTERPRETER_WASM_SHA256 = 'a2b36e8ac5a61caf3757af26aa79e83f2995b451099f44772383806a55fe3414';
+export const PINNED_INTERPRETER_WASM_SHA256 = 'b5ba1e35ccf20cd8c13c3a2c3098bf337033a92bcaf475d63c03ddc0cba0fcae';
 /** The grammar version the interpreter enforces (matches SELF_VERSION in
  *  contracts/policy-interpreter/src/version.rs). */
-export const PINNED_INTERPRETER_GRAMMAR_VERSION = 3;
+export const PINNED_INTERPRETER_GRAMMAR_VERSION = 4;
 /** Default Soroban RPC for the install / revoke / info tools. The recorder
  *  keeps its own copy in record/rpc.ts because it hands back a fetcher rather
  *  than a Server; the two are deliberately different surfaces, so this is
@@ -379,6 +404,18 @@ export const DeclarePolicyInputSchema = z
     recipients: z.array(z.string()).min(1, 'recipients must not be empty').optional(),
     recipientArgIndex: z.number().int().nonnegative().max(U32_MAX).optional(),
     allowZeroCap: z.boolean().optional(),
+    /** Minimum output as a ratio of the call's own input. num/den are decimal
+     *  STRINGS for the same reason maxAmount is: an i128 ratio does not
+     *  survive a JS number. */
+    minOutputRatio: z
+        .object({
+        num: z.string().regex(/^[0-9]+$/, 'num must be an unsigned integer'),
+        den: z.string().regex(/^[0-9]+$/, 'den must be an unsigned integer'),
+        inputArgIndex: z.number().int().nonnegative().max(U32_MAX),
+        outputArgIndex: z.number().int().nonnegative().max(U32_MAX),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 export const InstallPolicyInputSchema = z

package/dist/simulate/deny-cases.js

@@ -201,11 +201,22 @@ function visit(node, facts) {
             for (const child of node.children)
                 visit(child, facts);
             return;
+        // NOT descended into. A deny case works by violating ONE constraint and
+        // asserting the predicate refuses the call. Violating one branch of an
+        // `or` proves nothing, because another branch can still permit, so the
+        // generated case would either fail or pass for the wrong reason. A sound
+        // deny case for a disjunction must violate EVERY branch at once, which
+        // this generator does not construct - so it emits none.
+        case 'or':
+            return;
         case 'in':
             facts.memberships.push(node);
             return;
         case 'eq':
+        case 'lt':
         case 'lte':
+        case 'gt':
+        case 'gte':
             facts.comparisons.push(node);
     }
 }