@agentix-e/nl2spel 1.2.2 → 1.4.0

package/dist/index.js

@@ -1,47 +1,69 @@
 // src/provider/provider-registry.ts
 var ProviderRegistry = class {
   _providers = [];
-  /** Register a Provider */
-  register(provider) {
-    if (this._providers.some((p) => p.name === provider.name)) {
+  _nextIndex = 0;
+  /**
+   * Register a Provider.
+   * @param provider LLMProvider instance
+   * @param options.priority User-assigned priority (lower = preferred). Defaults to registration order.
+   */
+  register(provider, options) {
+    if (this._providers.some((p) => p.provider.name === provider.name)) {
       throw new Error(`Provider '${provider.name}' already registered`);
     }
-    this._providers.push(provider);
+    this._providers.push({
+      provider,
+      priority: options?.priority ?? this._nextIndex,
+      index: this._nextIndex
+    });
+    this._nextIndex++;
   }
   /** Unregister a Provider */
   unregister(name) {
-    this._providers = this._providers.filter((p) => p.name !== name);
+    this._providers = this._providers.filter((p) => p.provider.name !== name);
   }
   /** Get a Provider by name */
   get(name) {
-    return this._providers.find((p) => p.name === name);
+    return this._providers.find((p) => p.provider.name === name)?.provider;
   }
   /**
    * Get available Providers sorted by priority.
-   * Sort rule: offline > low cost > low latency > high accuracy
+   * Sort rule: offline first → user priority (asc) → registration order (asc)
    */
   async getPrioritized() {
     const available = [];
-    for (const p of this._providers) {
-      if (await p.isAvailable()) {
-        available.push(p);
+    for (const entry of this._providers) {
+      if (await entry.provider.isAvailable()) {
+        available.push(entry);
       }
     }
     return available.sort((a, b) => {
-      const aOffline = a.capabilities.offlineAvailable;
-      const bOffline = b.capabilities.offlineAvailable;
+      const aOffline = a.provider.capabilities.offlineAvailable;
+      const bOffline = b.provider.capabilities.offlineAvailable;
       if (aOffline && !bOffline) return -1;
       if (!aOffline && bOffline) return 1;
-      const costA = a.capabilities.estimatedCostPerRequest ?? Infinity;
-      const costB = b.capabilities.estimatedCostPerRequest ?? Infinity;
-      if (costA < costB) return -1;
-      if (costB < costA) return 1;
-      return a.capabilities.estimatedLatencyMs - b.capabilities.estimatedLatencyMs;
-    });
+      if (a.priority !== b.priority) return a.priority - b.priority;
+      return a.index - b.index;
+    }).map((entry) => entry.provider);
+  }
+  /**
+   * Explicitly reorder providers by name.
+   * Providers not listed retain their position after the reordered ones.
+   */
+  reorder(providerNames) {
+    const orderMap = new Map(providerNames.map((name, i) => [name, i]));
+    const maxExisting = this._providers.reduce(
+      (max, p) => Math.max(max, p.priority),
+      providerNames.length - 1
+    );
+    for (const entry of this._providers) {
+      const explicitIndex = orderMap.get(entry.provider.name);
+      entry.priority = explicitIndex ?? maxExisting + entry.index + 1;
+    }
   }
   /** List all registered Providers */
   list() {
-    return [...this._providers];
+    return this._providers.map((p) => p.provider);
   }
   /** Number of registered Providers */
   get count() {
@@ -372,10 +394,55 @@ var ChineseNumberParser = class {
 };
 
 // src/pattern/pattern-matcher.ts
+var UnmappedFieldError = class extends Error {
+  /** The field word that could not be resolved. */
+  field;
+  constructor(field) {
+    super(
+      `No field mapping for '${field}'. Add a mapping, or use fieldPolicy 'passthrough' to emit it verbatim.`
+    );
+    this.name = "UnmappedFieldError";
+    this.field = field;
+  }
+};
+var CN_FIELD_MAP = {
+  \u5907\u6CE8: "remark",
+  \u8BF4\u660E: "description",
+  \u63CF\u8FF0: "description",
+  \u91D1\u989D: "amount",
+  \u6570\u91CF: "count",
+  \u4E2A\u6570: "count",
+  \u72B6\u6001: "status",
+  \u7C7B\u578B: "type",
+  \u540D\u79F0: "name",
+  \u6807\u9898: "title",
+  \u5730\u5740: "address",
+  \u90AE\u7BB1: "email",
+  \u624B\u673A: "phone",
+  \u7535\u8BDD: "phone",
+  \u65E5\u671F: "date",
+  \u65F6\u95F4: "time",
+  \u5E74\u9F84: "age",
+  \u4EF7\u683C: "price",
+  \u7528\u6237\u540D: "name",
+  \u6743\u9650: "role",
+  \u6807\u7B7E: "tags",
+  \u5217\u8868: "list",
+  \u6570\u7EC4: "items",
+  \u6587\u4EF6: "file",
+  \u6587\u4EF6\u540D: "name",
+  \u8FC7\u671F: "expiryDate",
+  \u521B\u5EFA: "createdAt",
+  \u6709\u6548: "valid",
+  \u6D3B\u8DC3: "active",
+  \u6FC0\u6D3B: "active"
+};
 var PatternMatcher = class {
   _patterns;
-  constructor(patterns = []) {
+  fieldPolicy;
+  constructor(patterns = [], options = {}) {
     this._patterns = [...patterns];
+    this.fieldPolicy = options.fieldPolicy ?? "passthrough";
     this.sortByPriority();
   }
   get patternCount() {
@@ -409,9 +476,22 @@ var PatternMatcher = class {
           }
         }
       }
-      const spel = this.fillTemplate(pattern, slots, normalized, matchResult);
+      const { expression, unmappedFields } = this.fillTemplate(
+        pattern,
+        slots,
+        normalized,
+        matchResult
+      );
       const latencyMs2 = Date.now() - startTime;
-      return { matched: true, pattern, spel, confidence: pattern.confidence, latencyMs: latencyMs2, slots };
+      return {
+        matched: true,
+        pattern,
+        spel: expression,
+        confidence: pattern.confidence,
+        latencyMs: latencyMs2,
+        slots,
+        ...unmappedFields.length > 0 ? { unmappedFields } : {}
+      };
     }
     const latencyMs = Date.now() - startTime;
     return { matched: false, confidence: 0, latencyMs };
@@ -432,13 +512,20 @@ var PatternMatcher = class {
           if (value !== void 0) slots[key] = value;
         }
       }
+      const { expression, unmappedFields } = this.fillTemplate(
+        pattern,
+        slots,
+        normalized,
+        matchResult
+      );
       results.push({
         matched: true,
         pattern,
-        spel: this.fillTemplate(pattern, slots, normalized, matchResult),
+        spel: expression,
         confidence: pattern.confidence,
         latencyMs: 0,
-        slots
+        slots,
+        ...unmappedFields.length > 0 ? { unmappedFields } : {}
       });
     }
     return results;
@@ -460,46 +547,37 @@ var PatternMatcher = class {
     if (/^(?:商品|product|item)/i.test(input)) return "product";
     return "order";
   }
+  /**
+   * The first whitespace- or punctuation-delimited chunk of `input`.
+   */
+  firstWord(input) {
+    const m = input.match(/^[^\s，,、]+/);
+    return m ? m[0] : "value";
+  }
   /**
    * Extract Chinese field names from input and map to SpEL fields
    */
   extractChineseField(input) {
-    const m = input.match(/^[^\s，,、]+/);
-    if (!m) return "value";
-    const first = m[0];
-    const cnMap = {
-      \u5907\u6CE8: "remark",
-      \u8BF4\u660E: "description",
-      \u63CF\u8FF0: "description",
-      \u91D1\u989D: "amount",
-      \u6570\u91CF: "count",
-      \u4E2A\u6570: "count",
-      \u72B6\u6001: "status",
-      \u7C7B\u578B: "type",
-      \u540D\u79F0: "name",
-      \u6807\u9898: "title",
-      \u5730\u5740: "address",
-      \u90AE\u7BB1: "email",
-      \u624B\u673A: "phone",
-      \u7535\u8BDD: "phone",
-      \u65E5\u671F: "date",
-      \u65F6\u95F4: "time",
-      \u5E74\u9F84: "age",
-      \u4EF7\u683C: "price",
-      \u7528\u6237\u540D: "name",
-      \u6743\u9650: "role",
-      \u6807\u7B7E: "tags",
-      \u5217\u8868: "list",
-      \u6570\u7EC4: "items",
-      \u6587\u4EF6: "file",
-      \u6587\u4EF6\u540D: "name",
-      \u8FC7\u671F: "expiryDate",
-      \u521B\u5EFA: "createdAt",
-      \u6709\u6548: "valid",
-      \u6D3B\u8DC3: "active",
-      \u6FC0\u6D3B: "active"
-    };
-    return cnMap[first] ?? first;
+    const first = this.firstWord(input);
+    return CN_FIELD_MAP[first] ?? first;
+  }
+  /**
+   * Resolve a captured field word into the identifier to emit, and report whether
+   * the dictionary recognised it.
+   *
+   * An ASCII word is already an identifier and is emitted unchanged. Anything else
+   * is looked up: a word the dictionary knows becomes its English identifier, and a
+   * word it does not know is emitted verbatim and reported as unmapped. Emitting it
+   * verbatim is legal Spring, but it is a guess about the caller's schema, so the
+   * guess is never silent.
+   */
+  resolveField(captured) {
+    if (/^[a-zA-Z_]\w*$/.test(captured)) {
+      return { field: captured, mapped: true };
+    }
+    const first = this.firstWord(captured);
+    const mapped = CN_FIELD_MAP[first];
+    return { field: mapped ?? first, mapped: mapped !== void 0 };
   }
   /**
    * Template filling and value transformation
@@ -507,7 +585,20 @@ var PatternMatcher = class {
   fillTemplate(pattern, slots, originalInput, _matchResult) {
     let result = pattern.spelTemplate;
     const hasFieldSlot = "field" in slots;
-    const field = hasFieldSlot ? this.inferFieldFromCapture(slots["field"]) : this.extractChineseField(originalInput);
+    const unmappedFields = [];
+    let field;
+    if (hasFieldSlot) {
+      const resolved = this.resolveField(slots["field"]);
+      if (!resolved.mapped) {
+        if (this.fieldPolicy === "strict") {
+          throw new UnmappedFieldError(resolved.field);
+        }
+        unmappedFields.push(resolved.field);
+      }
+      field = resolved.field;
+    } else {
+      field = this.extractChineseField(originalInput);
+    }
     const root = this.inferRoot(originalInput);
     result = result.replace(/\{field\}/g, field);
     result = result.replace(/\{root\}/g, root);
@@ -535,14 +626,7 @@ var PatternMatcher = class {
       result = result.replace(`{${key}}`, transformedValue ?? "");
     }
     result = result.replace(/\{[a-zA-Z_]+\}/g, "");
-    return result.trim();
-  }
-  /**
-   * Infer SpEL field name from capture group
-   */
-  inferFieldFromCapture(captured) {
-    if (/^[a-zA-Z_]\w*$/.test(captured)) return captured;
-    return this.extractChineseField(captured);
+    return { expression: result.trim(), unmappedFields };
   }
 };
 
@@ -608,7 +692,7 @@ var BUILTIN_PATTERNS = [
     slots: {},
     priority: 98,
     tags: ["null", "isNotNull"],
-    examples: [{ nl: "\u5907\u6CE8\u4E0D\u4E3A\u7A7A", spel: "#\u5907\u6CE8 != null" }],
+    examples: [{ nl: "\u5907\u6CE8\u4E0D\u4E3A\u7A7A", spel: "#remark != null" }],
     difficulty: "easy",
     confidence: 0.98
   },
@@ -619,7 +703,7 @@ var BUILTIN_PATTERNS = [
     slots: {},
     priority: 97,
     tags: ["null", "isNull"],
-    examples: [{ nl: "\u5907\u6CE8\u4E3A\u7A7A", spel: "#\u5907\u6CE8 == null" }],
+    examples: [{ nl: "\u5907\u6CE8\u4E3A\u7A7A", spel: "#remark == null" }],
     difficulty: "easy",
     confidence: 0.98
   },
@@ -650,29 +734,29 @@ var BUILTIN_PATTERNS = [
   // ================================================================
   {
     id: "CN-CMP-GE",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:金额|值)?\s*(?:不小于|不低于|大于等于|>=)\s*(?<value>\d+(?:\.\d+)?)/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:不小于|不低于|大于等于|>=)\s*(?<value>\d+(?:\.\d+)?)/,
     spelTemplate: "#{field} >= {value}",
     slots: { value: { key: "value", type: "number", transform: "toNumber" } },
     priority: 93,
     tags: ["comparison", "ge", "chinese"],
-    examples: [{ nl: "\u91D1\u989D\u4E0D\u5C0F\u4E8E100", spel: "#\u91D1\u989D >= 100" }],
+    examples: [{ nl: "\u91D1\u989D\u4E0D\u5C0F\u4E8E100", spel: "#amount >= 100" }],
     difficulty: "easy",
     confidence: 0.95
   },
   {
     id: "CN-CMP-LE",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:金额|值)?\s*(?:不大于|不超过|小于等于|<=)\s*(?<value>\d+(?:\.\d+)?)/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:不大于|不超过|小于等于|<=)\s*(?<value>\d+(?:\.\d+)?)/,
     spelTemplate: "#{field} <= {value}",
     slots: { value: { key: "value", type: "number", transform: "toNumber" } },
     priority: 93,
     tags: ["comparison", "le", "chinese"],
-    examples: [{ nl: "\u91D1\u989D\u4E0D\u8D85\u8FC7500", spel: "#\u91D1\u989D <= 500" }],
+    examples: [{ nl: "\u91D1\u989D\u4E0D\u8D85\u8FC7500", spel: "#amount <= 500" }],
     difficulty: "easy",
     confidence: 0.95
   },
   {
     id: "CN-CMP-GT",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:金额|值|数量|价格)?\s*(?:大于|超过|高于)\s*(?<value>\d+(?:\.\d+)?)/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:大于|超过|高于)\s*(?<value>\d+(?:\.\d+)?)/,
     spelTemplate: "#{field} > {value}",
     slots: { value: { key: "value", type: "number", transform: "toNumber" } },
     priority: 92,
@@ -683,7 +767,7 @@ var BUILTIN_PATTERNS = [
   },
   {
     id: "CN-CMP-LT",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:金额|值|数量|价格)?\s*(?:小于|低于|不到)\s*(?<value>\d+(?:\.\d+)?)/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:小于|低于|不到)\s*(?<value>\d+(?:\.\d+)?)/,
     spelTemplate: "#{field} < {value}",
     slots: { value: { key: "value", type: "number", transform: "toNumber" } },
     priority: 92,
@@ -697,7 +781,7 @@ var BUILTIN_PATTERNS = [
   // ================================================================
   {
     id: "CN-EQ-STATUS",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:状态|类型)?\s*(?:等于|是|为)\s*(?<value>[^\s，,、]+)$/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:等于|是|为)\s*(?<value>[^\s，,、]+)$/,
     spelTemplate: "#{field} == '{value}'",
     slots: { value: { key: "value", type: "string" } },
     priority: 85,
@@ -720,7 +804,7 @@ var BUILTIN_PATTERNS = [
   // CN: "order status is not cancelled" — must be before NOT pattern
   {
     id: "CN-NE-STATUS",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:状态|类型)?\s*(?:不等于|!=|不是)\s*(?<value>[^\s，,、]+)$/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:不等于|!=|不是)\s*(?<value>[^\s，,、]+)$/,
     spelTemplate: "#{field} != '{value}'",
     slots: { value: { key: "value", type: "string" } },
     priority: 91,
@@ -743,12 +827,12 @@ var BUILTIN_PATTERNS = [
   // CN/EN: count equality
   {
     id: "CN-EQ-COUNT",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:数量|个数|计数)?\s*(?:等于|==)\s*(?<value>\d+)/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:等于|==)\s*(?<value>\d+)/,
     spelTemplate: "#{field} == {value}",
     slots: { value: { key: "value", type: "number", transform: "toNumber" } },
     priority: 91,
     tags: ["comparison", "eq", "number"],
-    examples: [{ nl: "\u6570\u91CF\u7B49\u4E8E5", spel: "#\u6570\u91CF == 5" }],
+    examples: [{ nl: "\u6570\u91CF\u7B49\u4E8E5", spel: "#count == 5" }],
     difficulty: "easy",
     confidence: 0.95
   },
@@ -790,7 +874,9 @@ var BUILTIN_PATTERNS = [
   },
   {
     id: "CN-PERM-PERM",
-    match: /^(?<field>[^\s，,、]+)\s*(?:可以|能够|允许|may|can)\s+(?<permission>.+)$/i,
+    // Chinese-only operator: keeping the English "can"/"may" here would let the
+    // pattern fire on the "can" inside "not cancelled".
+    match: /^(?<field>[^\s，,、]+)\s*(?:可以|能够|允许)\s*(?<permission>.+)$/,
     spelTemplate: "hasPermission('{permission}')",
     slots: { permission: { key: "permission", type: "string" } },
     priority: 88,
@@ -815,7 +901,7 @@ var BUILTIN_PATTERNS = [
   // ================================================================
   {
     id: "CN-COLL-EMPTY",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:列表|数组|集合)?\s*(?:为空|是空的|没有|无)\s*(?:元素|数据|项)?$/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:为空|是空的|没有|无)\s*(?:元素|数据|项)?$/,
     spelTemplate: "#{field}.isEmpty()",
     slots: {},
     priority: 89,
@@ -837,7 +923,7 @@ var BUILTIN_PATTERNS = [
   },
   {
     id: "CN-COLL-NOTEMPTY",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:列表|数组|集合)?\s*(?:不为空|有)\s*(?:元素|数据|项)?$/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:不为空|有)\s*(?:元素|数据|项)?$/,
     spelTemplate: "!#{field}.isEmpty()",
     slots: {},
     priority: 89,
@@ -859,7 +945,7 @@ var BUILTIN_PATTERNS = [
   },
   {
     id: "CN-COLL-CONTAINS",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:列表|数组|集合)?\s*(?:中\s*)?(?:包含|含有|有)\s*(?<element>[^\s，,、]+)/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:中\s*)?(?:包含|含有|有)\s*(?<element>[^\s，,、]+)/,
     spelTemplate: "#{field}.contains('{element}')",
     slots: { element: { key: "element", type: "string" } },
     priority: 87,
@@ -881,7 +967,7 @@ var BUILTIN_PATTERNS = [
   },
   {
     id: "CN-COLL-SIZE",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:列表|数组|集合)?\s*(?:数量|个数|大小|长度)\s*(?<op>大于|>|超过|小于|<|等于|==)\s*(?<value>\d+)/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:数量|个数|大小|长度)\s*(?<op>大于|>|超过|小于|<|等于|==)\s*(?<value>\d+)/,
     spelTemplate: "#{field}.size() {op} {value}",
     slots: {
       value: { key: "value", type: "number", transform: "toNumber" },
@@ -912,7 +998,7 @@ var BUILTIN_PATTERNS = [
   // ================================================================
   {
     id: "CN-STR-CONTAINS",
-    match: /^(?<field>[^\s，,、]+?)(?:备注|名称|描述|标签|标题)?\s*(?:包含|含有|包括)\s*(?<substr>[^\s，,、]+)/,
+    match: /^(?<field>[^\s，,、]+?)\s*(?:包含|含有|包括)\s*(?<substr>[^\s，,、]+)/,
     spelTemplate: "#{field}.contains('{substr}')",
     slots: { substr: { key: "substr", type: "string" } },
     priority: 85,
@@ -961,7 +1047,7 @@ var BUILTIN_PATTERNS = [
     slots: { suffix: { key: "suffix", type: "string" } },
     priority: 85,
     tags: ["string", "endsWith"],
-    examples: [{ nl: "\u6587\u4EF6\u540D\u4EE5.pdf\u7ED3\u5C3E", spel: "#\u6587\u4EF6\u540D.endsWith('.pdf')" }],
+    examples: [{ nl: "\u6587\u4EF6\u540D\u4EE5.pdf\u7ED3\u5C3E", spel: "#name.endsWith('.pdf')" }],
     difficulty: "easy",
     confidence: 0.95
   },
@@ -1004,21 +1090,21 @@ var BUILTIN_PATTERNS = [
   {
     id: "CN-RANGE-BETWEEN",
     match: /^(?<field>[^\s，,、]+?)\s*(?:在|介于)\s*(?<min>\d+)\s*(?:和|到|~)\s*(?<max>\d+)\s*(?:之间|范围)?/,
-    spelTemplate: "#{field} between {{{min}, {max}}}",
+    spelTemplate: "#{field} between {{min}, {max}}",
     slots: {
       min: { key: "min", type: "number", transform: "toNumber" },
       max: { key: "max", type: "number", transform: "toNumber" }
     },
     priority: 82,
     tags: ["range", "between"],
-    examples: [{ nl: "\u5E74\u9F84\u572818\u523060\u4E4B\u95F4", spel: "#\u5E74\u9F84 between {18, 60}" }],
+    examples: [{ nl: "\u5E74\u9F84\u572818\u523060\u4E4B\u95F4", spel: "#age between {18, 60}" }],
     difficulty: "easy",
     confidence: 0.95
   },
   {
     id: "EN-RANGE-BETWEEN",
     match: /\b(?<field>\w+)\s+between\s+(?<min>\d+)\s+and\s+(?<max>\d+)/i,
-    spelTemplate: "#{field} between {{{min}, {max}}}",
+    spelTemplate: "#{field} between {{min}, {max}}",
     slots: {
       min: { key: "min", type: "number", transform: "toNumber" },
       max: { key: "max", type: "number", transform: "toNumber" }
@@ -1039,7 +1125,7 @@ var BUILTIN_PATTERNS = [
     slots: { default: { key: "default", type: "string" } },
     priority: 78,
     tags: ["elvis"],
-    examples: [{ nl: "\u7528\u6237\u540D\u6216\u8005\u533F\u540D\u7528\u6237", spel: "#\u7528\u6237\u540D ?: '\u533F\u540D\u7528\u6237'" }],
+    examples: [{ nl: "\u7528\u6237\u540D\u6216\u8005\u533F\u540D\u7528\u6237", spel: "#name ?: '\u533F\u540D\u7528\u6237'" }],
     difficulty: "medium",
     confidence: 0.85
   },
@@ -1145,7 +1231,11 @@ var BUILTIN_PATTERNS = [
   // ================================================================
   {
     id: "CN-BOOL-TRUE",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:是|为|等于|==)\s*(?:true|真|是|yes)$/i,
+    // "用户是VIP" asserts the subject through a Latin marker, so accept either a
+    // truth word or a Latin word. A fully open marker would fire on function
+    // words ("一个非常…"), and the lookbehind keeps a negator out of the field
+    // ("用户不" is not the subject).
+    match: /^(?<field>[^\s，,、]+?)(?<![不非])\s*(?:是|为|等于|==)\s*(?:true|真|是|yes|[A-Za-z]\w*)$/,
     spelTemplate: "#{field} == true",
     slots: {},
     priority: 74,
@@ -1156,7 +1246,10 @@ var BUILTIN_PATTERNS = [
   },
   {
     id: "CN-BOOL-FALSE",
-    match: /^(?<field>[^\s，,、]+?)\s*(?:不是|非|为|是|等于|==)\s*(?:false|假|否|no)$/i,
+    // Mirror of CN-BOOL-TRUE. The marker stays narrow so that function words
+    // ("非常…") do not match, and the lookbehind keeps "不是有效" with
+    // CN-LOGIC-NOT instead of capturing "不" as the field.
+    match: /^(?<field>[^\s，,、]+?)(?<![不非])\s*(?:不是|非|为|是|等于|==)\s*(?:false|假|否|no|[A-Za-z]\w*)$/,
     spelTemplate: "#{field} == false",
     slots: {},
     priority: 73,
@@ -1264,7 +1357,7 @@ var BUILTIN_PATTERNS = [
   // ================================================================
   {
     id: "CN-LOGIC-NOT",
-    match: /^不是\s+(?<expr>.+)/,
+    match: /^不是\s*(?<expr>.+)/,
     spelTemplate: "!({expr})",
     slots: { expr: { key: "expr", type: "variable" } },
     priority: 62,
@@ -1289,8 +1382,8 @@ var BUILTIN_PATTERNS = [
   // ================================================================
   {
     id: "CN-SELECT-FIRST",
-    match: /^(?<root>[^\s，,、]+?)\s*中\s*第一[个位]\s*(?<field>[^\s，,、]+?)\s*(?:大于|>|超过|<|小于|等于|==)\s*(?<value>[^\s，,、]+)/,
-    spelTemplate: "#{root}.items.^[#{this}.{field} > {value}]",
+    match: /^(?<root>[^\s，,、]+?)\s*中\s*第一[个位]\s*(?<field>[^\s，,、]+?)\s*(?:大于|>|超过|<|小于|等于|==)\s*(?<value>[^\s，,、的]+)/,
+    spelTemplate: "#{root}.items.^[#this.{field} > {value}]",
     slots: {
       root: { key: "root", type: "variable" },
       field: { key: "field", type: "variable" },
@@ -1298,14 +1391,14 @@ var BUILTIN_PATTERNS = [
     },
     priority: 60,
     tags: ["selection", "first"],
-    examples: [{ nl: "\u8BA2\u5355\u4E2D\u7B2C\u4E00\u4E2A\u91D1\u989D\u5927\u4E8E1000\u7684", spel: "#\u8BA2\u5355.items.^[#this.\u91D1\u989D > 1000]" }],
+    examples: [{ nl: "\u8BA2\u5355\u4E2D\u7B2C\u4E00\u4E2A\u91D1\u989D\u5927\u4E8E1000\u7684", spel: "#order.items.^[#this.amount > 1000]" }],
     difficulty: "medium",
     confidence: 0.8
   },
   {
     id: "CN-SELECT-ALL",
-    match: /^(?<root>[^\s，,、]+?)\s*中\s*所有\s*(?<field>[^\s，,、]+?)\s*(?:大于|>|超过|<|小于|等于|==|包含|满足)\s*(?<value>[^\s，,、]+)/,
-    spelTemplate: "#{root}.items.?[#{this}.{field} > {value}]",
+    match: /^(?<root>[^\s，,、]+?)\s*中\s*所有\s*(?<field>[^\s，,、]+?)\s*(?:大于|>|超过|<|小于|等于|==|包含|满足)\s*(?<value>[^\s，,、的]+)/,
+    spelTemplate: "#{root}.items.?[#this.{field} > {value}]",
     slots: {
       root: { key: "root", type: "variable" },
       field: { key: "field", type: "variable" },
@@ -1313,28 +1406,28 @@ var BUILTIN_PATTERNS = [
     },
     priority: 60,
     tags: ["selection", "all"],
-    examples: [{ nl: "\u8BA2\u5355\u4E2D\u6240\u6709\u91D1\u989D\u5927\u4E8E1000\u7684", spel: "#\u8BA2\u5355.items.?[#this.\u91D1\u989D > 1000]" }],
+    examples: [{ nl: "\u8BA2\u5355\u4E2D\u6240\u6709\u91D1\u989D\u5927\u4E8E1000\u7684", spel: "#order.items.?[#this.amount > 1000]" }],
     difficulty: "medium",
     confidence: 0.8
   },
   {
     id: "CN-PROJ",
-    match: /^(?<root>[^\s，,、]+?)\s*中\s*每[个一]\s*(?:的)?(?<field>[^\s，,、]+?)\s*(?:值|金额|名称|价格|name|amount|price)?/,
-    spelTemplate: "#{root}.items.![#{this}.{field}]",
+    match: /^(?<root>[^\s，,、]+?)\s*中\s*每[个一]\s*(?:的)?(?<field>[^\s，,、]+?)\s*(?:的)?(?:值|金额|名称|价格|name|amount|price)?$/,
+    spelTemplate: "#{root}.items.![#this.{field}]",
     slots: {
       root: { key: "root", type: "variable" },
       field: { key: "field", type: "variable" }
     },
     priority: 55,
     tags: ["projection"],
-    examples: [{ nl: "\u8BA2\u5355\u4E2D\u6BCF\u4E2A\u5546\u54C1\u7684\u4EF7\u683C", spel: "#\u8BA2\u5355.items.![#this.\u5546\u54C1]" }],
+    examples: [{ nl: "\u8BA2\u5355\u4E2D\u6BCF\u4E2A\u5546\u54C1\u7684\u4EF7\u683C", spel: "#order.items.![#this.\u5546\u54C1]" }],
     difficulty: "medium",
     confidence: 0.75
   },
   {
     id: "EN-SELECT-ALL",
     match: /all\s+(?<root>\w+)\s+with\s+(?<field>\w+)\s*>\s*(?<value>\d+)/i,
-    spelTemplate: "#{root}.items.?[#{this}.{field} > {value}]",
+    spelTemplate: "#{root}.items.?[#this.{field} > {value}]",
     slots: {
       root: { key: "root", type: "variable" },
       field: { key: "field", type: "variable" },
@@ -1342,13 +1435,149 @@ var BUILTIN_PATTERNS = [
     },
     priority: 50,
     tags: ["selection", "all", "english"],
-    examples: [{ nl: "all items with price > 100", spel: "#items.items.?[#this.price > 100]" }],
+    examples: [{ nl: "all items with price > 100", spel: "#order.items.?[#this.price > 100]" }],
     difficulty: "medium",
     confidence: 0.8
   }
 ];
 BUILTIN_PATTERNS.sort((a, b) => b.priority - a.priority);
 
+// src/pattern/clause-splitter.ts
+var CONNECTORS = [
+  // Chinese conjunctions. `和` is deliberately absent: it is a range separator in
+  // `价格在10和20之间`, not a conjunction.
+  { pattern: /(?:并且|且|同时|而且|、)/y, operator: "and" },
+  { pattern: /(?:或者|或|要么)/y, operator: "or" },
+  // English conjunctions, matched as whole words.
+  { pattern: /\band\b/iy, operator: "and" },
+  { pattern: /\bor\b/iy, operator: "or" }
+];
+var UnconvertibleClauseError = class extends Error {
+  /** The clause texts that could not be converted. */
+  unconvertible;
+  /** The full input that was being decomposed. */
+  input;
+  constructor(input, unconvertible) {
+    const detail = unconvertible.map((clause) => `'${clause}'`).join(", ");
+    super(
+      `Cannot decompose '${input}': no conversion for ${detail}. Refusing to emit a partial rule.`
+    );
+    this.name = "UnconvertibleClauseError";
+    this.input = input;
+    this.unconvertible = unconvertible;
+  }
+};
+var QUOTES = /* @__PURE__ */ new Set(["'", '"']);
+var OPENERS = { "(": ")", "[": "]", "{": "}" };
+var CLOSERS = /* @__PURE__ */ new Set([")", "]", "}"]);
+var isDigit = (ch) => ch !== void 0 && ch >= "0" && ch <= "9";
+function nextConnector(input, from) {
+  let depth = 0;
+  let quote = null;
+  for (let i = from; i < input.length; i += 1) {
+    const ch = input[i];
+    if (quote !== null) {
+      if (ch === quote) {
+        if (input[i + 1] === quote) {
+          i += 1;
+          continue;
+        }
+        quote = null;
+      }
+      continue;
+    }
+    if (QUOTES.has(ch)) {
+      quote = ch;
+      continue;
+    }
+    if (ch in OPENERS) {
+      depth += 1;
+      continue;
+    }
+    if (CLOSERS.has(ch)) {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth > 0) continue;
+    for (const { pattern, operator } of CONNECTORS) {
+      pattern.lastIndex = i;
+      const match = pattern.exec(input);
+      if (!match) continue;
+      if (operator === "and") {
+        let before = i - 1;
+        while (before >= 0 && input[before] === " ") before -= 1;
+        let after = i + match[0].length;
+        while (after < input.length && input[after] === " ") after += 1;
+        if (isDigit(input[before]) && isDigit(input[after])) continue;
+      }
+      return { index: i, length: match[0].length, operator };
+    }
+  }
+  return null;
+}
+function splitClauses(input) {
+  const clauses = [];
+  let start = 0;
+  let connector = "and";
+  let cursor = 0;
+  for (; ; ) {
+    const found = nextConnector(input, cursor);
+    if (found === null) break;
+    clauses.push({ text: input.slice(start, found.index).trim(), connector });
+    connector = found.operator;
+    start = found.index + found.length;
+    cursor = start;
+  }
+  const tail = input.slice(start).trim();
+  if (clauses.length > 0 || tail.length > 0) {
+    clauses.push({ text: tail, connector });
+  }
+  if (clauses.length === 0) {
+    clauses.push({ text: "", connector: "and" });
+  }
+  return clauses;
+}
+function groupByPrecedence(clauses) {
+  const groups = [];
+  let current = [];
+  for (const clause of clauses) {
+    if (clause.connector === "or" && current.length > 0) {
+      groups.push(current);
+      current = [];
+    }
+    current.push(clause);
+  }
+  if (current.length > 0) groups.push(current);
+  return groups;
+}
+function decompose(input, convert) {
+  const clauses = splitClauses(input);
+  if (clauses.length <= 1) return null;
+  const unconvertible = [];
+  const resolved = clauses.map((clause) => {
+    const expression = clause.text.length === 0 ? null : convert(clause.text);
+    if (expression === null) {
+      unconvertible.push(clause.text);
+      return { ...clause, expression: "" };
+    }
+    return { ...clause, expression };
+  });
+  if (unconvertible.length > 0) {
+    throw new UnconvertibleClauseError(input, unconvertible);
+  }
+  const groups = groupByPrecedence(resolved);
+  const mixed = groups.length > 1;
+  const rendered = groups.map((group) => {
+    const parts = group.map((clause) => `(${clause.expression})`);
+    const joined = parts.join(" and ");
+    return mixed && group.length > 1 ? `(${joined})` : joined;
+  });
+  return {
+    expression: rendered.join(" or "),
+    clauses: clauses.map((clause) => clause.text)
+  };
+}
+
 // src/template/nl-intent.ts
 var NLIntent = /* @__PURE__ */ ((NLIntent2) => {
   NLIntent2["COMPARISON"] = "COMPARISON";
@@ -1387,7 +1616,7 @@ var INTENT_KEYWORDS = {
     en: ["greater", "less", "equal", "above", "below", "exceed", ">", "<", "==", "!=", ">=", "<="]
   },
   ["NULL_CHECK" /* NULL_CHECK */]: {
-    zh: ["\u4E3A\u7A7A", "\u4E0D\u4E3A\u7A7A", "\u662F\u7A7A", "\u5B58\u5728", "\u4E0D\u5B58\u5728", "null", "\u6CA1\u6709\u503C"],
+    zh: ["\u4E3A\u7A7A", "\u4E0D\u4E3A\u7A7A", "\u662F\u7A7A", "\u975E\u7A7A", "\u5B58\u5728", "\u4E0D\u5B58\u5728", "\u6709\u503C", "\u65E0\u503C", "null", "\u6CA1\u6709\u503C"],
     en: ["null", "empty", "is null", "is not null", "is empty", "is not empty"]
   },
   ["PERMISSION_CHECK" /* PERMISSION_CHECK */]: {
@@ -1424,7 +1653,10 @@ var INTENT_KEYWORDS = {
   },
   ["BOOLEAN" /* BOOLEAN */]: {
     zh: ["\u662F\u5426", "\u771F\u5047", "true", "false", "\u662F", "\u5426"],
-    en: ["true", "false", "yes", "no", "is", "is not"]
+    // "no" is deliberately absent: it is a substring of "not", so it fired on
+    // every negated null/emptiness phrase and made "remark is not empty" a
+    // boolean check. "false"/"否" already cover the negative boolean spelling.
+    en: ["true", "false", "yes", "is", "is not"]
   },
   ["DATE" /* DATE */]: {
     zh: ["\u65E5\u671F", "\u65F6\u95F4", "\u4E4B\u540E", "\u4E4B\u524D", "\u65E9\u4E8E", "\u665A\u4E8E"],
@@ -1443,6 +1675,38 @@ var INTENT_KEYWORDS = {
     en: ["plus", "minus", "multiply", "divide", "mod", "sum", "average"]
   }
 };
+var NULL_NEGATED_SPECIFIC = [
+  "\u4E0D\u4E3A\u7A7A",
+  "\u4E0D\u4E3Anull",
+  "\u4E0D\u662F\u7A7A",
+  "\u975E\u7A7A",
+  "is not null",
+  "is not empty"
+];
+var NULL_AFFIRMATIVE = [
+  "\u4E0D\u5B58\u5728",
+  "\u65E0\u503C",
+  "\u6CA1\u6709\u503C",
+  "\u4E3A\u7A7A",
+  "\u4E3Anull",
+  "\u662F\u7A7A",
+  "is null",
+  "is empty"
+];
+var NULL_NEGATED_GENERIC = ["\u6709\u503C", "\u5B58\u5728"];
+function detectNullPredicate(input) {
+  const text = input.trim().toLowerCase().replace(/[\uFF01-\uFF5E]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 65248)).replace(/\s+/g, " ");
+  for (const token of NULL_NEGATED_SPECIFIC) {
+    if (text.includes(token)) return "negated";
+  }
+  for (const token of NULL_AFFIRMATIVE) {
+    if (text.includes(token)) return "affirmative";
+  }
+  for (const token of NULL_NEGATED_GENERIC) {
+    if (text.includes(token)) return "negated";
+  }
+  return null;
+}
 var IntentClassifier = class {
   /**
    * Main method for classifying natural language input
@@ -1476,6 +1740,9 @@ var IntentClassifier = class {
     if (/isempty|\.isEmpty|列表|数组|集合/.test(normalized)) {
       intentScores.set("COLLECTION" /* COLLECTION */, (intentScores.get("COLLECTION" /* COLLECTION */) ?? 0) + 1);
     }
+    if (detectNullPredicate(normalized)) {
+      intentScores.set("NULL_CHECK" /* NULL_CHECK */, (intentScores.get("NULL_CHECK" /* NULL_CHECK */) ?? 0) + 2);
+    }
     const entities = this.extractEntities(normalized);
     const operators = this.extractOperators(normalized);
     const logicalConnectors = this.extractLogicalConnectors(normalized);
@@ -1588,6 +1855,68 @@ var IntentClassifier = class {
 };
 
 // src/template/template-engine.ts
+var CHINESE_FIELD_MAP = {
+  \u5907\u6CE8: "remark",
+  \u8BF4\u660E: "description",
+  \u63CF\u8FF0: "description",
+  \u91D1\u989D: "amount",
+  \u6570\u91CF: "count",
+  \u4E2A\u6570: "count",
+  \u72B6\u6001: "status",
+  \u7C7B\u578B: "type",
+  \u540D\u79F0: "name",
+  \u6807\u9898: "title",
+  \u5730\u5740: "address",
+  \u90AE\u7BB1: "email",
+  \u624B\u673A: "phone",
+  \u7535\u8BDD: "phone",
+  \u65E5\u671F: "date",
+  \u65F6\u95F4: "time",
+  \u5E74\u9F84: "age",
+  \u4EF7\u683C: "price",
+  \u7528\u6237\u540D: "name",
+  \u6743\u9650: "role",
+  \u6807\u7B7E: "tags",
+  \u5217\u8868: "list",
+  \u6570\u7EC4: "items",
+  \u6587\u4EF6: "file",
+  \u6587\u4EF6\u540D: "name",
+  \u8FC7\u671F: "expiryDate",
+  \u521B\u5EFA: "createdAt",
+  \u6709\u6548: "valid",
+  \u6D3B\u8DC3: "active",
+  \u6FC0\u6D3B: "active"
+};
+var CHINESE_FIELDS_BY_LENGTH = Object.entries(CHINESE_FIELD_MAP).sort(
+  (a, b) => b[0].length - a[0].length
+);
+var FIELD_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "account",
+  "and",
+  "are",
+  "be",
+  "between",
+  "empty",
+  "false",
+  "file",
+  "has",
+  "have",
+  "is",
+  "no",
+  "not",
+  "null",
+  "or",
+  "order",
+  "product",
+  "than",
+  "the",
+  "true",
+  "user",
+  "value",
+  "yes"
+]);
 var TEMPLATE_LIBRARY = {
   ["COMPARISON" /* COMPARISON */]: [
     {
@@ -1832,8 +2161,9 @@ var TemplateEngine = class {
   selectBestTemplate(templates, intentResult, input) {
     let bestScore = -1;
     let bestTemplate = null;
-    const hasEmptyKeyword = /为空|empty|null/i.test(input);
-    const hasNotEmptyKeyword = /不为空|not empty|not null/i.test(input);
+    const polarity = detectNullPredicate(input);
+    const isAffirmative = polarity === "affirmative";
+    const isNegated = polarity === "negated";
     for (const template of templates) {
       const conditions = template.conditions;
       let score = 0;
@@ -1842,8 +2172,10 @@ var TemplateEngine = class {
       if (conditions.hasCollection) score += 0.5;
       if (conditions.hasNull) score += 0.5;
       if (conditions.hasString) score += 1;
-      if (template.name.includes("IS_EMPTY") && hasEmptyKeyword) score += 2;
-      if (template.name.includes("IS_NOT_EMPTY") && hasNotEmptyKeyword) score += 2;
+      if (template.name.includes("IS_EMPTY") && isAffirmative) score += 2;
+      if (template.name.includes("IS_NOT_EMPTY") && isNegated) score += 2;
+      if (template.name === "NULL-IS_NULL" && isAffirmative) score += 2;
+      if (template.name === "NULL-IS_NOT_NULL" && isNegated) score += 2;
       if (conditions.entityCount) {
         if (conditions.entityCount.min && intentResult.entities.length < conditions.entityCount.min) {
           continue;
@@ -1859,37 +2191,8 @@ var TemplateEngine = class {
   fillTemplate(template, input, intentResult) {
     let expression = template;
     const unfilledSlots = [];
-    let rootName = "order";
-    let fieldName = "field";
-    if (this.contextSchema?.root) {
-      rootName = this.contextSchema.root.name;
-      const fields = Object.keys(this.contextSchema.root.fields ?? {});
-      for (const f of fields) {
-        if (input.includes(f)) {
-          fieldName = f;
-          break;
-        }
-      }
-    } else {
-      const rootMap = {
-        \u8BA2\u5355: "order",
-        order: "order",
-        \u7528\u6237: "user",
-        user: "user",
-        \u6587\u4EF6: "file",
-        file: "file",
-        \u8D26\u53F7: "account",
-        account: "account",
-        \u5546\u54C1: "item",
-        product: "item"
-      };
-      for (const [key, val] of Object.entries(rootMap)) {
-        if (input.includes(key)) {
-          rootName = val;
-          break;
-        }
-      }
-    }
+    const rootName = this.resolveRootName(input);
+    const fieldName = this.resolveFieldName(input);
     expression = expression.replace(/\{root\}/g, rootName);
     expression = expression.replace(/\{field\}/g, fieldName);
     const fieldEntities = intentResult.entities.filter((e) => e.type === "field");
@@ -1958,6 +2261,58 @@ var TemplateEngine = class {
     }
     return { expression, unfilledSlots };
   }
+  /**
+   * Resolve the SpEL root name for `input`: the configured schema root when one
+   * exists, otherwise a keyword heuristic over the well-known roots.
+   */
+  resolveRootName(input) {
+    if (this.contextSchema?.root) {
+      return this.contextSchema.root.name;
+    }
+    const rootMap = {
+      \u8BA2\u5355: "order",
+      order: "order",
+      \u7528\u6237: "user",
+      user: "user",
+      \u6587\u4EF6: "file",
+      file: "file",
+      \u8D26\u53F7: "account",
+      account: "account",
+      \u5546\u54C1: "item",
+      product: "item"
+    };
+    for (const [key, val] of Object.entries(rootMap)) {
+      if (input.includes(key)) return val;
+    }
+    return "order";
+  }
+  /**
+   * Resolve the field name for `input`.
+   *
+   * The previous implementation only compared schema *keys* and otherwise left
+   * the literal placeholder default in place, which is how "#order.field == null"
+   * reached callers. The lookup now falls back in order: schema key, schema
+   * field description (Chinese inputs name the field by its description),
+   * Chinese field word, first English identifier, and finally "value" — the
+   * neutral default the pattern layer already uses for an unknown field.
+   */
+  resolveFieldName(input) {
+    const fields = this.contextSchema?.root?.fields;
+    if (fields) {
+      for (const [key, schema] of Object.entries(fields)) {
+        if (input.includes(key)) return key;
+        if (schema.description && input.includes(schema.description)) return key;
+      }
+    }
+    for (const [word, field] of CHINESE_FIELDS_BY_LENGTH) {
+      if (input.includes(word)) return field;
+    }
+    const tokens = input.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? [];
+    for (const token of tokens) {
+      if (!FIELD_STOPWORDS.has(token.toLowerCase())) return token;
+    }
+    return "value";
+  }
 };
 
 // src/template/prompts/prompt-builder.ts
@@ -2195,6 +2550,172 @@ ${userInput}
   }
 };
 
+// src/validation/validation-pipeline.ts
+import { TokenKind, Tokenizer } from "@agentix-e/spel-ts";
+
+// src/validation/auto-fixer.ts
+function scanStringLiterals(expression) {
+  const spans = [];
+  let unterminatedQuote = null;
+  let i = 0;
+  while (i < expression.length) {
+    const quote = expression[i];
+    if (quote !== "'" && quote !== '"') {
+      i += 1;
+      continue;
+    }
+    const start = i;
+    i += 1;
+    let closed = false;
+    while (i < expression.length) {
+      if (expression[i] === quote) {
+        if (expression[i + 1] === quote) {
+          i += 2;
+          continue;
+        }
+        i += 1;
+        closed = true;
+        break;
+      }
+      i += 1;
+    }
+    spans.push({ start, end: i });
+    if (!closed) {
+      unterminatedQuote = quote;
+      break;
+    }
+  }
+  return { spans, unterminatedQuote };
+}
+function hasUnterminatedStringLiteral(expression) {
+  return scanStringLiterals(expression).unterminatedQuote !== null;
+}
+function maskStringLiterals(expression) {
+  const { spans } = scanStringLiterals(expression);
+  if (spans.length === 0) return expression;
+  const chars = expression.split("");
+  for (const span of spans) {
+    for (let i = span.start; i < span.end && i < chars.length; i++) {
+      chars[i] = " ";
+    }
+  }
+  return chars.join("");
+}
+var AutoFixer = class {
+  fix(expression) {
+    const { chunks, unterminatedQuote } = this.split(expression);
+    const changes = [];
+    this.applyRule(
+      chunks,
+      /=== undefined/g,
+      "== null",
+      () => "Replaced === undefined with == null",
+      changes
+    );
+    this.applyRule(
+      chunks,
+      /!== undefined/g,
+      "!= null",
+      () => "Replaced !== undefined with != null",
+      changes
+    );
+    this.applyRule(chunks, /!==/g, "!=", (n) => `Replaced ${n}x !== with !=`, changes);
+    this.applyRule(chunks, /===/g, "==", (n) => `Replaced ${n}x === with ==`, changes);
+    this.applyRule(chunks, /&&/g, "and", (n) => `Replaced ${n}x && with and`, changes);
+    this.applyRule(chunks, /\|\|/g, "or", (n) => `Replaced ${n}x || with or`, changes);
+    this.applyRule(chunks, /> ==/g, ">=", () => "Replaced > == with >=", changes);
+    this.applyRule(chunks, /< ==/g, "<=", () => "Replaced < == with <=", changes);
+    this.applyElvisRule(chunks, changes);
+    let fixed = chunks.map((chunk) => chunk.text).join("");
+    if (unterminatedQuote !== null && !fixed.endsWith(unterminatedQuote)) {
+      fixed += unterminatedQuote;
+      changes.push(
+        unterminatedQuote === "'" ? "Added missing closing single quote" : "Added missing closing double quote"
+      );
+    }
+    const wasFixed = changes.length > 0;
+    return {
+      wasFixed,
+      expression: wasFixed ? fixed : expression,
+      changes
+    };
+  }
+  /**
+   * Apply one global replacement rule to every unprotected chunk.
+   *
+   * The replacement is only reported when it actually matched, and the count
+   * is the number of matches across all chunks, so the human-readable change
+   * log is unchanged from the previous implementation.
+   */
+  applyRule(chunks, pattern, replacement, describe, changes) {
+    let count = 0;
+    for (const chunk of chunks) {
+      if (chunk.protected) continue;
+      const matches = chunk.text.match(pattern);
+      if (matches === null) continue;
+      count += matches.length;
+      chunk.text = chunk.text.replace(pattern, replacement);
+    }
+    if (count > 0) {
+      changes.push(describe(count));
+    }
+  }
+  /**
+   * Normalise the Elvis operator only when it was written with whitespace
+   * between `?` and `:`. A correctly written `?:` must be left untouched so
+   * that `fix()` is a no-op on already-valid input.
+   */
+  applyElvisRule(chunks, changes) {
+    let touched = false;
+    for (const chunk of chunks) {
+      if (chunk.protected || !chunk.text.includes("? :")) continue;
+      const next = chunk.text.replace(/\s*\?\s*:\s*/g, " ?: ");
+      if (next !== chunk.text) {
+        chunk.text = next;
+        touched = true;
+      }
+    }
+    if (touched) {
+      changes.push("Fixed Elvis operator spacing");
+    }
+  }
+  /**
+   * Split the expression into alternating protected (string literal) and
+   * unprotected chunks. Ranges come from spel-ts's tokenizer so they agree
+   * exactly with what the parser considers opaque.
+   */
+  split(expression) {
+    const { spans, unterminatedQuote } = scanStringLiterals(expression);
+    return { chunks: this.toChunks(expression, spans), unterminatedQuote };
+  }
+  /**
+   * Turn protected spans into a chunk list covering the whole expression.
+   */
+  toChunks(expression, spans) {
+    const ordered = [...spans].sort((a, b) => a.start - b.start);
+    const chunks = [];
+    let cursor = 0;
+    for (const span of ordered) {
+      const start = Math.max(span.start, cursor);
+      const end = Math.max(span.end, start);
+      if (start > cursor) {
+        chunks.push({ protected: false, text: expression.slice(cursor, start) });
+      }
+      if (end > start) {
+        chunks.push({ protected: true, text: expression.slice(start, end) });
+      }
+      cursor = end;
+    }
+    if (cursor < expression.length) {
+      chunks.push({ protected: false, text: expression.slice(cursor) });
+    }
+    if (chunks.length === 0) {
+      chunks.push({ protected: false, text: "" });
+    }
+    return chunks;
+  }
+};
+
 // src/validation/validation-pipeline.ts
 var ValidationPipeline = class {
   evaluator;
@@ -2214,25 +2735,29 @@ var ValidationPipeline = class {
     const typeStage = this.validateTypes(expression, contextSchema);
     const semanticStage = this.validateSemantic(expression);
     const contextStage = this.validateContext(expression, contextSchema);
+    const finalStage = this.validateFinal(expression);
     errors.push(
       ...parseStage.errors,
       ...typeStage.errors,
       ...semanticStage.errors,
-      ...contextStage.errors
+      ...contextStage.errors,
+      ...finalStage.errors
     );
     warnings.push(
       ...parseStage.warnings,
       ...typeStage.warnings,
       ...semanticStage.warnings,
-      ...contextStage.warnings
+      ...contextStage.warnings,
+      ...finalStage.warnings
     );
     return {
-      valid: parseStage.passed && typeStage.passed && semanticStage.passed && contextStage.passed,
+      valid: errors.length === 0,
       stages: {
         parse: parseStage,
         type: typeStage,
         semantic: semanticStage,
-        context: contextStage
+        context: contextStage,
+        final: finalStage
       },
       errors,
       warnings
@@ -2240,47 +2765,57 @@ var ValidationPipeline = class {
   }
   /**
    * Stage 1: Parse Check — syntax validation
+   *
+   * Delimiter balance and JavaScript operators are checked against a copy of
+   * the expression with string literals blanked out, so literal text can never
+   * be mistaken for syntax.
    */
   async validateParse(expression) {
     const errors = [];
     const warnings = [];
+    const structural = maskStringLiterals(expression);
     if (!expression || expression.trim().length === 0) {
       errors.push({
         code: "PARSE-EMPTY",
         message: "Expression is empty",
+        severity: "error",
         stage: "parse",
         requiresLLM: true
       });
       return { passed: false, errors, warnings };
     }
-    if (!this.hasBalancedParentheses(expression)) {
+    if (!this.hasBalancedParentheses(structural)) {
       errors.push({
         code: "PARSE-UNBALANCED_PARENS",
         message: "Unbalanced parentheses in expression",
+        severity: "error",
         stage: "parse",
         requiresLLM: true
       });
     }
-    if (expression.includes("===") || expression.includes("!==")) {
+    if (structural.includes("===") || structural.includes("!==")) {
       errors.push({
         code: "PARSE-JS_OPERATOR",
         message: "JavaScript operators detected (=== or !==), use == or != in SpEL",
+        severity: "error",
         stage: "parse",
         requiresLLM: true
       });
     }
-    if (expression.includes("&&")) {
+    if (structural.includes("&&")) {
       errors.push({
         code: "PARSE-JS_LOGIC",
         message: 'JavaScript && detected, use "and" in SpEL',
+        severity: "error",
         stage: "parse",
         requiresLLM: true
       });
     }
-    if (expression.includes("||")) {
+    if (structural.includes("||")) {
       errors.push({
         code: "PARSE-JS_LOGIC",
         message: 'JavaScript || detected, use "or" in SpEL',
+        severity: "error",
         stage: "parse",
         requiresLLM: true
       });
@@ -2293,6 +2828,7 @@ var ValidationPipeline = class {
             errors.push({
               code: `PARSE-${pe.code ?? "SYNTAX"}`,
               message: pe.message,
+              severity: "error",
               position: pe.position,
               stage: "parse",
               requiresLLM: true
@@ -2303,6 +2839,7 @@ var ValidationPipeline = class {
         errors.push({
           code: "PARSE-EXCEPTION",
           message: `Parse threw exception: ${err.message}`,
+          severity: "error",
           stage: "parse",
           requiresLLM: true
         });
@@ -2315,27 +2852,43 @@ var ValidationPipeline = class {
     };
   }
   /**
-   * Stage 2: Type Check — type validation
+   * Stage 2: Type Check — advisory type validation
    */
   validateTypes(expression, contextSchema) {
     const errors = [];
     const warnings = [];
-    const strNumMismatch = /'(?:\\.|[^'\\])*'\s*(?:>|<|>=|<=)\s*\d+/;
+    const structural = maskStringLiterals(expression);
+    const strNumMismatch = /'(?:\\.|[^'\\])*'\s*(?:>|<|>=|<=)\s*\d+|\d+\s*(?:>|<|>=|<=)\s*'(?:\\.|[^'\\])*'/;
     if (strNumMismatch.test(expression)) {
       warnings.push({
         code: "TYPE-STR_NUM_CMP",
         message: "String literal compared with number using arithmetic operator",
+        severity: "warning",
         stage: "type"
       });
     }
     if (contextSchema?.root) {
+      const rootRef = escapeRegExp(contextSchema.root.name);
       for (const [fieldName, field] of Object.entries(contextSchema.root.fields)) {
+        const fieldRef = `#(?:${rootRef}\\.)?${escapeRegExp(fieldName)}`;
         if (field.type === "boolean") {
-          const boolNumPattern = new RegExp(`#\\w+\\.${fieldName}\\s*(?:>|<|>=|<=)\\s*\\d+`);
-          if (boolNumPattern.test(expression)) {
+          const boolNumPattern = new RegExp(`${fieldRef}\\s*(?:>|<|>=|<=)\\s*\\d+`);
+          if (boolNumPattern.test(structural)) {
             warnings.push({
               code: "TYPE-BOOL_NUM_CMP",
               message: `Boolean field '${fieldName}' compared with number`,
+              severity: "warning",
+              stage: "type"
+            });
+          }
+        }
+        if (field.type === "number") {
+          const numStrPattern = new RegExp(`${fieldRef}\\s*(?:>|<|>=|<=)\\s*'(?:\\\\.|[^'\\\\])*'`);
+          if (numStrPattern.test(expression)) {
+            warnings.push({
+              code: "TYPE-STR_NUM_CMP",
+              message: `Numeric field '${fieldName}' compared with a string literal`,
+              severity: "warning",
               stage: "type"
             });
           }
@@ -2349,23 +2902,26 @@ var ValidationPipeline = class {
     };
   }
   /**
-   * Stage 3: Semantic Check — semantic reasonableness validation
+   * Stage 3: Semantic Check — advisory semantic validation
    */
   validateSemantic(expression) {
     const errors = [];
     const warnings = [];
+    const structural = maskStringLiterals(expression);
     const selfCompare = /(#\w+(?:\.\w+)*)\s*==\s*\1/;
-    if (selfCompare.test(expression)) {
+    if (selfCompare.test(structural)) {
       warnings.push({
         code: "SEM-SELF_COMPARE",
         message: "Self-comparison detected: expression is always true",
+        severity: "warning",
         stage: "semantic"
       });
     }
-    if (expression.includes("!!")) {
+    if (structural.includes("!!")) {
       warnings.push({
         code: "SEM-DOUBLE_NEGATION",
         message: "Double negation detected, consider simplifying",
+        severity: "warning",
         stage: "semantic"
       });
     }
@@ -2377,59 +2933,72 @@ var ValidationPipeline = class {
   }
   /**
    * Stage 4: Context Check — context reference validation
+   *
+   * A supplied schema turns this stage into a real gate: an undeclared bean,
+   * a missing root field or an undeclared variable is an error. Without a
+   * schema nothing can be judged, so the stage stays advisory.
    */
   validateContext(expression, contextSchema) {
     const errors = [];
     const warnings = [];
+    const structural = maskStringLiterals(expression);
     if (!contextSchema) {
       warnings.push({
         code: "CTX-NO_SCHEMA",
         message: "No ContextSchema provided, skipping context validation",
+        severity: "warning",
         stage: "context"
       });
       return { passed: true, errors, warnings };
     }
-    const refs = this.extractReferences(expression);
-    if (contextSchema.root) {
-      const rootName = contextSchema.root.name;
+    const variables = contextSchema.variables ?? {};
+    const functions = contextSchema.functions ?? {};
+    const beans = contextSchema.beans ?? {};
+    const root = contextSchema.root;
+    const rootFields = root?.fields ?? {};
+    const refs = this.extractReferences(structural);
+    if (root) {
       for (const ref of refs) {
-        if (ref.startsWith(`#${rootName}`)) {
-          const parts = ref.split(".");
-          const field = parts[1];
-          if (field && !(field in contextSchema.root.fields)) {
-            warnings.push({
-              code: "CTX-UNKNOWN_FIELD",
-              message: `Field '${field}' not found in root '${rootName}'`,
-              stage: "context"
-            });
-          }
+        if (!ref.startsWith(`#${root.name}.`)) continue;
+        const field = ref.split(".")[1];
+        if (field && !(field in rootFields)) {
+          errors.push({
+            code: "CTX-UNKNOWN_FIELD",
+            message: `Field '${field}' not found in root '${root.name}'`,
+            severity: "error",
+            stage: "context",
+            requiresLLM: true
+          });
         }
       }
     }
     for (const ref of refs) {
-      if (ref.startsWith("#") && !ref.includes(".")) {
-        const varName = ref.slice(1);
-        const isRoot = contextSchema.root?.name === varName;
-        const isVariable = varName in contextSchema.variables;
-        const isFunction = varName in contextSchema.functions;
-        if (!isRoot && !isVariable && !isFunction) {
-          warnings.push({
-            code: "CTX-UNKNOWN_REF",
-            message: `Unknown reference '${ref}'`,
-            stage: "context"
-          });
-        }
+      if (!ref.startsWith("#") || ref.includes(".")) continue;
+      const varName = ref.slice(1);
+      const known = varName === "this" || varName === "root" || root?.name === varName || varName in variables || varName in functions || // A bare `#name` may also name a root field, which the generator emits
+      // as shorthand for `#root.name`.
+      varName in rootFields;
+      if (!known) {
+        errors.push({
+          code: "CTX-UNKNOWN_REF",
+          message: `Unknown reference '${ref}'`,
+          severity: "error",
+          stage: "context",
+          requiresLLM: true
+        });
       }
     }
-    const beanMatch = expression.match(/@(\w+)/g);
-    if (beanMatch && contextSchema.beans) {
+    const beanMatch = structural.match(/@(\w+)/g);
+    if (beanMatch) {
       for (const b of beanMatch) {
         const beanName = b.slice(1);
-        if (!(beanName in contextSchema.beans)) {
-          warnings.push({
+        if (!(beanName in beans)) {
+          errors.push({
             code: "CTX-UNKNOWN_BEAN",
             message: `Bean '${beanName}' not found in ContextSchema`,
-            stage: "context"
+            severity: "error",
+            stage: "context",
+            requiresLLM: true
           });
         }
       }
@@ -2441,7 +3010,62 @@ var ValidationPipeline = class {
     };
   }
   /**
-   * Check if parentheses are balanced
+   * Stage 5: Final Check — the generated expression must parse.
+   *
+   * When an evaluator is configured the parse stage already performed a real
+   * parse; this mandatory final gate adds the structural check that a truncated
+   * tail (an expression ending on an operator) is never accepted, even when no
+   * engine is wired in. It is deliberately conservative: only a trailing
+   * operator or an unterminated literal fails, so no well-formed expression is
+   * rejected.
+   */
+  validateFinal(expression) {
+    const errors = [];
+    const warnings = [];
+    if (this.isManifestlyIncomplete(expression)) {
+      errors.push({
+        code: "FINAL-TRUNCATED",
+        message: "Expression is incomplete: it ends with an operator or is not terminated",
+        severity: "error",
+        stage: "final",
+        requiresLLM: true
+      });
+    }
+    return { passed: errors.length === 0, errors, warnings };
+  }
+  /**
+   * Whether the expression is obviously incomplete.
+   *
+   * The last token is obtained from spel-ts's tokenizer, so a trailing
+   * operator keyword or an unterminated string literal is detected exactly,
+   * and text inside a literal is never read as a trailing operator.
+   */
+  isManifestlyIncomplete(expression) {
+    if (expression.trim().length === 0) return true;
+    const tokenizer = new Tokenizer(expression);
+    let lastKind = null;
+    let lastLiteral;
+    let previousKind = null;
+    try {
+      for (; ; ) {
+        const token = tokenizer.nextToken();
+        if (token.kind === TokenKind.EOF) break;
+        previousKind = lastKind;
+        lastKind = token.kind;
+        lastLiteral = token.literal;
+      }
+    } catch {
+      return hasUnterminatedStringLiteral(expression);
+    }
+    if (lastKind === null) return true;
+    if (INCOMPLETE_TRAILING_TOKENS.has(lastKind)) return true;
+    if (lastLiteral !== void 0 && /^[A-Za-z]+$/.test(lastLiteral) && lastKind !== TokenKind.LITERAL_STRING && previousKind !== TokenKind.DOT && previousKind !== TokenKind.SAFE_NAV && WORD_OPERATORS.has(lastLiteral.toLowerCase())) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if parentheses are balanced. Expects a literal-masked expression.
    */
   hasBalancedParentheses(expression) {
     const stack = [];
@@ -2457,17 +3081,29 @@ var ValidationPipeline = class {
     return stack.length === 0;
   }
   /**
-   * Extract all identifier references from expression
+   * Extract all identifier references from expression.
+   *
+   * A bare `#x` that is only the head of a dotted reference (`#x.y`) is not
+   * emitted on its own: a dotted reference names a property of some object,
+   * not a variable of that name.
    */
   extractReferences(expression) {
     const refs = [];
+    const dottedHeads = /* @__PURE__ */ new Set();
     const varMatch = expression.matchAll(/#(\w+(?:\.\w+(?:\.\w+)?)?)/g);
     for (const m of varMatch) {
-      refs.push(`#${m[1]}`);
+      const ref = `#${m[1]}`;
+      if (!refs.includes(ref)) {
+        refs.push(ref);
+      }
+      if (ref.includes(".")) {
+        dottedHeads.add(ref.split(".")[0]);
+      }
     }
     const simpleMatch = expression.matchAll(/#(\w+)(?!\w*\()/g);
     for (const m of simpleMatch) {
       const ref = `#${m[1]}`;
+      if (dottedHeads.has(ref)) continue;
       if (!refs.includes(ref)) {
         refs.push(ref);
       }
@@ -2475,98 +3111,68 @@ var ValidationPipeline = class {
     return refs;
   }
 };
-
-// src/validation/auto-fixer.ts
-var AutoFixer = class {
-  fix(expression) {
-    let fixed = expression;
-    const changes = [];
-    if (fixed.includes("=== undefined")) {
-      fixed = fixed.replace(/=== undefined/g, "== null");
-      changes.push("Replaced === undefined with == null");
-    }
-    if (fixed.includes("!== undefined")) {
-      fixed = fixed.replace(/!== undefined/g, "!= null");
-      changes.push("Replaced !== undefined with != null");
-    }
-    if (fixed.includes("!==")) {
-      const count = fixed.match(/!==/g).length;
-      fixed = fixed.replace(/!==/g, "!=");
-      changes.push(`Replaced ${count}x !== with !=`);
-    }
-    if (fixed.includes("===")) {
-      const count = fixed.match(/===/g).length;
-      fixed = fixed.replace(/===/g, "==");
-      changes.push(`Replaced ${count}x === with ==`);
-    }
-    if (fixed.includes("&&")) {
-      const count = fixed.match(/&&/g).length;
-      fixed = fixed.replace(/&&/g, "and");
-      changes.push(`Replaced ${count}x && with and`);
-    }
-    if (fixed.includes("||")) {
-      const count = fixed.match(/\|\|/g).length;
-      fixed = fixed.replace(/\|\|/g, "or");
-      changes.push(`Replaced ${count}x || with or`);
-    }
-    const singleQuoteCount = (fixed.match(/'/g) ?? []).length;
-    if (singleQuoteCount % 2 !== 0) {
-      if (!fixed.endsWith("'")) {
-        fixed = fixed + "'";
-        changes.push("Added missing closing single quote");
-      }
-    }
-    const doubleQuoteCount = (fixed.match(/"/g) ?? []).length;
-    if (doubleQuoteCount % 2 !== 0) {
-      if (!fixed.endsWith('"')) {
-        fixed = fixed + '"';
-        changes.push("Added missing closing double quote");
-      }
-    }
-    const parenFix = this.fixAllBrackets(fixed);
-    if (parenFix !== fixed) {
-      changes.push("Fixed unbalanced brackets");
-      fixed = parenFix;
-    }
-    if (fixed.includes("> ==")) {
-      fixed = fixed.replace(/> ==/g, ">=");
-      changes.push("Replaced > == with >=");
-    }
-    if (fixed.includes("< ==")) {
-      fixed = fixed.replace(/< ==/g, "<=");
-      changes.push("Replaced < == with <=");
-    }
-    if (fixed.includes("? :")) {
-      fixed = fixed.replace(/\?\s*:\s*/g, " ?: ");
-      changes.push("Fixed Elvis operator spacing");
-    }
-    const wasFixed = changes.length > 0;
-    return {
-      wasFixed,
-      expression: wasFixed ? fixed : expression,
-      changes
-    };
-  }
-  fixAllBrackets(expr) {
-    let result = expr;
-    const openParen = (result.match(/\(/g) ?? []).length;
-    const closeParen = (result.match(/\)/g) ?? []).length;
-    if (openParen > closeParen) {
-      result += ")".repeat(openParen - closeParen);
-    }
-    const openBracket = (result.match(/\[/g) ?? []).length;
-    const closeBracket = (result.match(/\]/g) ?? []).length;
-    if (openBracket > closeBracket) {
-      result += "]".repeat(openBracket - closeBracket);
-    }
-    const openBrace = (result.match(/\{/g) ?? []).length;
-    const closeBrace = (result.match(/\}/g) ?? []).length;
-    if (openBrace > closeBrace) {
-      result += "}".repeat(openBrace - closeBrace);
-    }
-    return result;
-  }
-};
+var INCOMPLETE_TRAILING_TOKENS = /* @__PURE__ */ new Set([
+  TokenKind.PLUS,
+  TokenKind.MINUS,
+  TokenKind.STAR,
+  TokenKind.SLASH,
+  TokenKind.PERCENT,
+  TokenKind.MOD,
+  TokenKind.POWER,
+  TokenKind.INC,
+  TokenKind.DEC,
+  TokenKind.EQ,
+  TokenKind.NE,
+  TokenKind.LT,
+  TokenKind.LE,
+  TokenKind.GT,
+  TokenKind.GE,
+  TokenKind.AND,
+  TokenKind.OR,
+  TokenKind.NOT,
+  TokenKind.ASSIGN,
+  TokenKind.MATCHES,
+  TokenKind.BETWEEN,
+  TokenKind.INSTANCEOF,
+  TokenKind.LPAREN,
+  TokenKind.LBRACKET,
+  TokenKind.LBRACE,
+  TokenKind.COMMA,
+  TokenKind.COLON,
+  TokenKind.DOT,
+  TokenKind.SAFE_NAV,
+  TokenKind.QMARK,
+  TokenKind.ELVIS,
+  TokenKind.HASH,
+  TokenKind.AT,
+  TokenKind.AMP_AT,
+  TokenKind.PROJECTION,
+  TokenKind.SELECTION,
+  TokenKind.SELECT_FIRST,
+  TokenKind.SELECT_LAST,
+  TokenKind.TYPE_START,
+  TokenKind.NEW,
+  TokenKind.DOTDOT
+]);
+var WORD_OPERATORS = /* @__PURE__ */ new Set([
+  "and",
+  "or",
+  "not",
+  "matches",
+  "between",
+  "instanceof",
+  // The textual operators in Spring's ALTERNATIVE_OPERATOR_NAMES (`eq`, `ne`,
+  // `div`, …) tokenize as their own kinds where the engine defines one, and as
+  // plain identifiers where it does not. `div` is the one that has no kind on
+  // the engine build this package compiles against — `1 div 2` tokenizes as
+  // IDENTIFIER — so it is listed here to keep `#a div` from passing as complete.
+  // A property named `div` is still safe: the preceding-dot guard below exempts
+  // `#order.div`.
+  "div"
+]);
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/validation/self-correction-loop.ts
 var SelfCorrectionLoop = class {
@@ -2724,20 +3330,23 @@ var StrategyRouter = class {
     if (contextSchema) {
       this.templateEngine.setContext(contextSchema);
     }
-    const patternResult = this.patternMatcher.match(nl);
-    if (patternResult.matched && patternResult.confidence >= this.config.patternMinConfidence) {
-      const validation = await this.validationPipeline.validate(patternResult.spel, contextSchema);
+    const isCompound = splitClauses(nl).length > 1;
+    let clauseFailure = null;
+    const wholeMatch = this.patternMatcher.match(nl);
+    const wholeIsFaithful = wholeMatch.matched && wholeMatch.confidence >= this.config.patternMinConfidence && (!isCompound || (wholeMatch.pattern?.tags.includes("logic") ?? false));
+    if (wholeIsFaithful) {
+      const validation = await this.validationPipeline.validate(wholeMatch.spel, contextSchema);
       if (validation.valid) {
         return {
-          expression: patternResult.spel,
+          expression: wholeMatch.spel,
           strategy: "pattern",
-          confidence: patternResult.confidence,
-          metadata: { patternId: patternResult.pattern?.id },
+          confidence: wholeMatch.confidence,
+          metadata: { patternId: wholeMatch.pattern?.id },
           latencyMs: Date.now() - startTime
         };
       }
       try {
-        const afResult = this.autoFixer.fix(patternResult.spel);
+        const afResult = this.autoFixer.fix(wholeMatch.spel);
         if (afResult.wasFixed) {
           const afValidation = await this.validationPipeline.validate(
             afResult.expression,
@@ -2747,8 +3356,8 @@ var StrategyRouter = class {
             return {
               expression: afResult.expression,
               strategy: "pattern",
-              confidence: patternResult.confidence * 0.95,
-              metadata: { patternId: patternResult.pattern?.id },
+              confidence: wholeMatch.confidence * 0.95,
+              metadata: { patternId: wholeMatch.pattern?.id },
               latencyMs: Date.now() - startTime
             };
           }
@@ -2756,6 +3365,30 @@ var StrategyRouter = class {
       } catch {
       }
     }
+    if (isCompound && !wholeIsFaithful) {
+      let decomposition = null;
+      try {
+        decomposition = this.decomposeClauses(nl);
+      } catch (error) {
+        if (!(error instanceof UnconvertibleClauseError)) throw error;
+        clauseFailure = error;
+      }
+      if (decomposition) {
+        const validation = await this.validationPipeline.validate(
+          decomposition.expression,
+          contextSchema
+        );
+        if (validation.valid) {
+          return {
+            expression: decomposition.expression,
+            strategy: "pattern",
+            confidence: decomposition.confidence,
+            metadata: { clauses: decomposition.clauses },
+            latencyMs: Date.now() - startTime
+          };
+        }
+      }
+    }
     const intentResult = this.intentClassifier.classify(nl);
     let templateResult = null;
     try {
@@ -2789,7 +3422,7 @@ var StrategyRouter = class {
       }
     }
     if (providers.length === 0) {
-      throw new Error("No LLM providers available");
+      throw clauseFailure ?? new Error("No LLM providers available");
     }
     let lastError = null;
     for (const provider of providers) {
@@ -2835,6 +3468,33 @@ var StrategyRouter = class {
   /**
    * Get PatternMatcher (for external testing/debugging)
    */
+  /**
+   * Convert a sentence that joins its clauses with a logical connector.
+   *
+   * Returns `null` when `nl` has no top-level connector, in which case the caller
+   * should use its ordinary single-pass conversion. Throws
+   * {@link UnconvertibleClauseError} when a clause cannot be converted, so the
+   * caller can refuse instead of emitting a partial rule.
+   */
+  decomposeClauses(nl) {
+    if (splitClauses(nl).length <= 1) return null;
+    const confidences = [];
+    const convert = (clause) => {
+      const result = this.patternMatcher.match(clause);
+      if (!result.matched || result.confidence < this.config.patternMinConfidence) {
+        return null;
+      }
+      confidences.push(result.confidence);
+      return result.spel;
+    };
+    const decomposition = decompose(nl, convert);
+    if (decomposition === null) return null;
+    return {
+      expression: decomposition.expression,
+      clauses: decomposition.clauses,
+      confidence: confidences.length > 0 ? Math.min(...confidences) : 0
+    };
+  }
   getPatternMatcher() {
     return this.patternMatcher;
   }
@@ -2918,6 +3578,19 @@ var NL2SpelEngine = class {
     if (options.offlineOnly) {
       const patternMatcher = this.router.getPatternMatcher();
       const patternResult = patternMatcher.match(nl);
+      const isCompound = splitClauses(nl).length > 1;
+      const wholeIsFaithful = patternResult.matched && (patternResult.pattern?.tags.includes("logic") ?? false);
+      if (isCompound && !wholeIsFaithful) {
+        const decomposition = this.router.decomposeClauses(nl);
+        if (decomposition) {
+          return {
+            expression: decomposition.expression,
+            strategy: "pattern",
+            confidence: decomposition.confidence,
+            latencyMs: Date.now() - startTime
+          };
+        }
+      }
       if (patternResult.matched) {
         return {
           expression: patternResult.spel,
@@ -2995,5 +3668,9 @@ export {
   SelfCorrectionLoop,
   StrategyRouter,
   TemplateEngine,
-  ValidationPipeline
+  UnconvertibleClauseError,
+  UnmappedFieldError,
+  ValidationPipeline,
+  decompose,
+  splitClauses
 };