@wowok/agent-mcp 2.3.1 → 2.3.3

package/dist/schema/call/guard.js

@@ -2,28 +2,81 @@ import { z } from 'zod';
 import { CallEnvSchema, NamedObjectSchema, SubmissionCallSchema } from './base.js';
 import { GuardNodeSchema } from '../query/index.js';
 import { DescriptionSchema, GuardTableItemBaseSchema, NameOrAddressSchema } from '../common/index.js';
-export const CallGuard_RootSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("node"),
-        node: GuardNodeSchema.describe("Guard computational tree root node. MUST return a Bool value (pass/fail)."),
-    }).strict(),
+import { isBoolReturningQuery } from '../utils/guard-query-utils.js';
+import { ValueType } from '@wowok/wowok';
+export const CallGuard_RootSchema = z.union([
+    GuardNodeSchema.refine((node) => {
+        const allowedTypes = [
+            'logic_as_u256_greater', 'logic_as_u256_lesser', 'logic_as_u256_equal',
+            'logic_as_u256_greater_or_equal', 'logic_as_u256_lesser_or_equal',
+            'logic_equal', 'logic_not', 'logic_and', 'logic_or',
+            'logic_string_contains', 'logic_string_nocase_contains', 'logic_string_nocase_equal',
+            'calc_string_contains', 'calc_string_nocase_contains', 'calc_string_nocase_equal',
+            'vec_contains_bool', 'vec_contains_address', 'vec_contains_string',
+            'vec_contains_string_nocase', 'vec_contains_number',
+            'query_reward_record_exists',
+            'query',
+            'identifier'
+        ];
+        if (!allowedTypes.includes(node.type)) {
+            return false;
+        }
+        if (node.type === 'query') {
+            const queryNode = node;
+            if (!isBoolReturningQuery(queryNode.query)) {
+                return false;
+            }
+        }
+        return true;
+    }, {
+        message: "Guard root node must be an operation that returns Bool. Allowed types: logic_*, calc_string_contains, calc_string_nocase_*, vec_contains_*, reward_record_exist, identifier (must reference Bool type in table). For 'query' type, ONLY queries that return Bool are allowed. Use 'wowok_buildin_info' tool with {\"info\": \"guard instructions\", \"filter\": {\"returnType\": \"Bool\", \"scope\": \"object query\"}} to list all Bool-returning queries. Other nodes (calc_number_*, context, non-Bool queries) must be wrapped with a logic operation."
+    }).describe("Guard computational tree root node. MUST be an operation that returns a Bool value (pass/fail). For 'query' type, the specific query must return Bool. For 'identifier' type, the referenced table item must have value_type=Bool."),
     z.object({
         type: z.literal("file"),
         file_path: z.string().describe("Path to JSON or Markdown file containing Guard definition. File can define: namedNew, description, table, root, rely."),
         format: z.enum(["json", "markdown"]).optional().default("json")
             .describe("File format: 'json' or 'markdown'. Default is 'json'."),
     }).strict(),
-]).describe("Guard root definition. Either provide a direct node tree or reference a file to load. When using file type, fields defined in the schema (namedNew, description, table, rely) will OVERRIDE the corresponding fields in the file.");
+]).describe("Guard root definition. Either provide a direct GuardNode tree (must be a logical operation returning Bool) or reference a file to load. When using file type, fields defined in the schema (namedNew, description, table, rely) will OVERRIDE the corresponding fields in the file.");
+const isBoolValueType = (valueType) => {
+    if (typeof valueType === 'number') {
+        return valueType === ValueType.Bool;
+    }
+    if (typeof valueType === 'string') {
+        return valueType.toLowerCase() === 'bool' || valueType === '0';
+    }
+    return false;
+};
 export const CallGuard_DataSchema = z.object({
     namedNew: NamedObjectSchema.optional().describe("Name and optional tags for the new Guard object. Set 'onChain: true' to create a public on-chain identity. When using root.type='file', this field OVERRIDES namedNew in the file."),
     description: DescriptionSchema.optional().describe("Guard description. When using root.type='file', this field OVERRIDES description in the file."),
     table: z.array(GuardTableItemBaseSchema).optional().describe("Data table of the Guard object. When using root.type='file', this field OVERRIDES table in the file."),
-    root: CallGuard_RootSchema.describe("Root definition: either a direct node tree (type='node') or a file reference (type='file'). When type='file', the file can define all Guard fields (namedNew, description, table, root, rely), and schema fields override file content."),
+    root: CallGuard_RootSchema.describe("Root definition: either a direct GuardNode (must be a logical operation returning Bool) or a file reference (type='file'). When type='file', the file can define all Guard fields (namedNew, description, table, root, rely), and schema fields override file content."),
     rely: z.object({
         guards: z.array(NameOrAddressSchema).describe("List of dependent Guard object IDs or names."),
         logic_or: z.boolean().optional().describe("Whether to use logical OR operator."),
     }).optional().describe("All Guard objects that the new Guard object depends on. If logic_or is true, the execution result of the new Guard object is the logical OR of the execution results of all dependent Guard objects; otherwise, it is logical AND. When using root.type='file', this field OVERRIDES rely in the file."),
-}).strict().describe("On-chain Guard creation. IMPORTANT: All defined data (include all submitted data) must be defined in the 'table' field. USAGE: Set 'namedNew' field with {name, tags?, onChain?} to name the new Guard. The Guard is immutable once created. Define the validation logic in 'root' field. When root.type='file', the file can contain all Guard fields, and any fields defined in the schema will OVERRIDE the file content.");
+}).strict().refine((data) => {
+    if (typeof data.root === 'object' && data.root !== null && 'type' in data.root) {
+        const rootObj = data.root;
+        if (rootObj.type === 'file') {
+            return true;
+        }
+    }
+    const rootNode = data.root;
+    if (rootNode.type === 'identifier' && rootNode.identifier !== undefined) {
+        const tableItem = data.table?.find(item => item.identifier === rootNode.identifier);
+        if (!tableItem) {
+            return false;
+        }
+        if (!isBoolValueType(tableItem.value_type)) {
+            return false;
+        }
+    }
+    return true;
+}, {
+    message: "Invalid Guard root: When using 'identifier' as root, the referenced table item must exist and have value_type='Bool' (or 0)."
+}).describe("On-chain Guard creation. IMPORTANT: All defined data (include all submitted data) must be defined in the 'table' field. USAGE: Set 'namedNew' field with {name, tags?, onChain?} to name the new Guard. The Guard is immutable once created. Define the validation logic in 'root' field. When root.type='file', the file can contain all Guard fields, and any fields defined in the schema will OVERRIDE the file content.");
 export const CallGuard_InputSchema = z.object({
     data: CallGuard_DataSchema.describe("Guard data definition."),
     env: CallEnvSchema.optional(),

package/dist/schema/query/index.js

@@ -625,58 +625,58 @@ export const GuardNodeSchema = z.lazy(() => z.discriminatedUnion('type', [
             identifier: GuardIdentifierSchema,
         }).strict().describe("Reference to the Reward object in the Guard table (must be Address type)."),
         find: z.enum(['first', 'last']).describe("'first' finds the earliest matching record, 'last' finds the most recent matching record."),
-        recipient: GuardNodeSchema.describe("GuardNode that returns the recipient address to search for (must be Address type). Typically an 'identifier' node referencing the recipient's address from the Guard table."),
+        recipient: z.object({
+            identifier: GuardIdentifierSchema,
+        }).strict().optional().describe("Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address."),
         where: z.object({
             guard: z.string().optional().describe("Optional filter: Guard object address constant to match."),
             timeMin: z.string().optional().describe("Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value."),
             timeMax: z.string().optional().describe("Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value."),
             amountMin: z.string().optional().describe("Optional filter: minimum reward amount (inclusive). Use string to represent U64 value."),
             amountMax: z.string().optional().describe("Optional filter: maximum reward amount (inclusive). Use string to represent U64 value."),
-            storeFromId: z.union([
-                z.literal('exists'),
-                z.literal('not_exists'),
-                z.object({ eq: z.string().describe("Address string to match") })
-            ]).optional().describe("Optional filter for store_from_id field: 'exists' means any value exists, 'not_exists' means no value, {eq: string} matches specific address."),
+            storeFromId: z.object({
+                identifier: GuardIdentifierSchema,
+            }).strict().optional().describe("Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants."),
         }).strict().describe("Filter conditions for the reward record query."),
-    }).strict().describe("Returns U64. Finds the index of the first or last reward record matching the specified recipient and filter conditions. Returns the record index (U64) if found. Throws error if no matching record is found (Guard validation fails)."),
+    }).strict().describe("Returns U64. Finds the index of the first or last reward record matching the specified recipient and filter conditions. Returns the record index (U64) if found. Throws error if no matching record is found (Guard validation fails). If recipient is not specified, uses the transaction signer address."),
     z.object({
         type: z.literal('query_reward_record_count'),
         object: z.object({
             identifier: GuardIdentifierSchema,
         }).strict().describe("Reference to the Reward object in the Guard table (must be Address type)."),
-        recipient: GuardNodeSchema.describe("GuardNode that returns the recipient address to count records for (must be Address type). Typically an 'identifier' node referencing the recipient's address from the Guard table."),
+        recipient: z.object({
+            identifier: GuardIdentifierSchema,
+        }).strict().optional().describe("Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address."),
         where: z.object({
             guard: z.string().optional().describe("Optional filter: Guard object address constant to match."),
             timeMin: z.string().optional().describe("Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value."),
             timeMax: z.string().optional().describe("Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value."),
             amountMin: z.string().optional().describe("Optional filter: minimum reward amount (inclusive). Use string to represent U64 value."),
             amountMax: z.string().optional().describe("Optional filter: maximum reward amount (inclusive). Use string to represent U64 value."),
-            storeFromId: z.union([
-                z.literal('exists'),
-                z.literal('not_exists'),
-                z.object({ eq: z.string().describe("Address string to match") })
-            ]).optional().describe("Optional filter for store_from_id field: 'exists' means any value exists, 'not_exists' means no value, {eq: string} matches specific address."),
+            storeFromId: z.object({
+                identifier: GuardIdentifierSchema,
+            }).strict().optional().describe("Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants."),
         }).strict().describe("Filter conditions for the reward record count query."),
-    }).strict().describe("Returns U64. Counts the number of reward records matching the specified recipient and filter conditions."),
+    }).strict().describe("Returns U64. Counts the number of reward records matching the specified recipient and filter conditions. If recipient is not specified, uses the transaction signer address."),
     z.object({
         type: z.literal('query_reward_record_exists'),
         object: z.object({
             identifier: GuardIdentifierSchema,
         }).strict().describe("Reference to the Reward object in the Guard table (must be Address type)."),
-        recipient: GuardNodeSchema.describe("GuardNode that returns the recipient address to check records for (must be Address type). Typically an 'identifier' node referencing the recipient's address from the Guard table."),
+        recipient: z.object({
+            identifier: GuardIdentifierSchema,
+        }).strict().optional().describe("Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address."),
         where: z.object({
             guard: z.string().optional().describe("Optional filter: Guard object address constant to match."),
             timeMin: z.string().optional().describe("Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value."),
             timeMax: z.string().optional().describe("Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value."),
             amountMin: z.string().optional().describe("Optional filter: minimum reward amount (inclusive). Use string to represent U64 value."),
             amountMax: z.string().optional().describe("Optional filter: maximum reward amount (inclusive). Use string to represent U64 value."),
-            storeFromId: z.union([
-                z.literal('exists'),
-                z.literal('not_exists'),
-                z.object({ eq: z.string().describe("Address string to match") })
-            ]).optional().describe("Optional filter for store_from_id field: 'exists' means any value exists, 'not_exists' means no value, {eq: string} matches specific address."),
+            storeFromId: z.object({
+                identifier: GuardIdentifierSchema,
+            }).strict().optional().describe("Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants."),
         }).strict().describe("Filter conditions for the reward record existence query."),
-    }).strict().describe("Returns Bool. Returns true if at least one reward record exists matching the specified recipient and filter conditions, otherwise false."),
+    }).strict().describe("Returns Bool. Returns true if at least one reward record exists matching the specified recipient and filter conditions, otherwise false. If recipient is not specified, uses the transaction signer address."),
     z.object({
         type: z.literal('query_progress_history_find'),
         object: z.object({

package/dist/schema/utils/guard-parser.js

@@ -1,5 +1,6 @@
 import { GuardNodeSchema } from '../query/index.js';
 import { CallGuard_DataSchema } from '../call/guard.js';
+import { isBoolReturningQuery, BOOL_RETURNING_QUERIES } from './guard-query-utils.js';
 function detectFormat(text) {
     const trimmed = text.trim();
     if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
@@ -344,6 +345,23 @@ export function parseGuardFromText(text) {
     }
     const result = CallGuard_DataSchema.safeParse(parsedData);
     if (result.success) {
+        const root = result.data.root;
+        if (typeof root === 'object' && root !== null && 'type' in root) {
+            const rootNode = root;
+            if (rootNode.type === 'query' && rootNode.query !== undefined) {
+                if (!isBoolReturningQuery(rootNode.query)) {
+                    const queryStr = typeof rootNode.query === 'number' ? `ID ${rootNode.query}` : `"${rootNode.query}"`;
+                    const boolQueryExamples = BOOL_RETURNING_QUERIES.slice(0, 5).map(q => `"${q.name}"`).join(', ');
+                    return {
+                        success: false,
+                        errors: [{
+                                message: `Invalid Guard root: query ${queryStr} does not return Bool. Only queries that return Bool can be used as root. Examples: ${boolQueryExamples}... Use guard2file to see all Bool-returning queries.`,
+                                path: '/root/query',
+                            }]
+                    };
+                }
+            }
+        }
         return { success: true, data: result.data, errors: [] };
     }
     for (const issue of result.error.issues) {

package/dist/schema/utils/guard-query-utils.d.ts

@@ -3,3 +3,9 @@ export declare const isValidGuardQueryName: (name: string) => boolean;
 export declare const isValidGuardQueryIdOrName: (input: number | string) => boolean;
 export declare const getGuardQueryByIdOrName: (input: number | string) => import("@wowok/wowok").GuardQuery | undefined;
 export declare const GUARD_QUERY_NAMES: string[];
+export declare const isBoolReturningQuery: (input: number | string) => boolean;
+export declare const BOOL_RETURNING_QUERIES: {
+    id: number;
+    name: string;
+    description: string;
+}[];

package/dist/schema/utils/guard-query-utils.js

@@ -1,6 +1,8 @@
-import { GUARDQUERY } from "@wowok/wowok";
+import { GUARDQUERY, ValueType } from "@wowok/wowok";
 const validGuardQueryIds = new Set(GUARDQUERY.map(item => item.id));
 const validGuardQueryNames = new Set(GUARDQUERY.map(item => item.name.toLowerCase()));
+const boolReturningQueryIds = new Set(GUARDQUERY.filter(item => item.return === ValueType.Bool).map(item => item.id));
+const boolReturningQueryNames = new Set(GUARDQUERY.filter(item => item.return === ValueType.Bool).map(item => item.name.toLowerCase()));
 export const isValidGuardQueryId = (id) => {
     return validGuardQueryIds.has(id);
 };
@@ -20,3 +22,12 @@ export const getGuardQueryByIdOrName = (input) => {
     return GUARDQUERY.find(item => item.name.toLowerCase() === input.toLowerCase());
 };
 export const GUARD_QUERY_NAMES = GUARDQUERY.map(item => item.name);
+export const isBoolReturningQuery = (input) => {
+    if (typeof input === 'number') {
+        return boolReturningQueryIds.has(input);
+    }
+    return boolReturningQueryNames.has(input.toLowerCase());
+};
+export const BOOL_RETURNING_QUERIES = GUARDQUERY
+    .filter(item => item.return === ValueType.Bool)
+    .map(item => ({ id: item.id, name: item.name, description: item.description }));

package/dist/schema-query/index.js

@@ -38,6 +38,51 @@ export function getSchema(name) {
             return null;
         }
         const content = readFileSync(schemaPath, "utf-8");
+        const schema = JSON.parse(content);
+        return resolveSchemaRefs(schema);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveSchemaRefs(schema, visited = new Set()) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => resolveSchemaRefs(item, visited));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === "$ref" && typeof value === "string") {
+            const refSchema = loadRefSchema(value, visited);
+            if (refSchema) {
+                Object.assign(result, resolveSchemaRefs(refSchema, visited));
+            }
+        }
+        else if (typeof value === "object") {
+            result[key] = resolveSchemaRefs(value, visited);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function loadRefSchema(ref, visited) {
+    if (ref.startsWith("#")) {
+        return null;
+    }
+    if (visited.has(ref)) {
+        return { description: `Circular reference to ${ref}` };
+    }
+    visited.add(ref);
+    try {
+        const refPath = join(SCHEMAS_DIR, ref);
+        if (!existsSync(refPath)) {
+            return null;
+        }
+        const content = readFileSync(refPath, "utf-8");
         return JSON.parse(content);
     }
     catch {

package/dist/schemas/guard-node-examples.md

@@ -0,0 +1,199 @@
+# GuardNode Usage Guide
+
+This document provides practical examples of GuardNode usage for AI agents.
+
+## Overview
+
+A GuardNode is a computational tree node that represents an operation returning a typed value. Nodes can be nested to build complex validation logic. The root node of a Guard MUST return a `Bool` value (pass/fail).
+
+## Common Patterns
+
+### Pattern 1: Verify Transaction Signer is Order Owner
+
+```json
+{
+  "type": "logic_equal",
+  "nodes": [
+    { "type": "context", "context": "Signer" },
+    {
+      "type": "query",
+      "query": 1562,
+      "object": { "identifier": 0 },
+      "parameters": []
+    }
+  ]
+}
+```
+
+**Explanation:**
+- `context: Signer` returns the transaction sender's address
+- `query: 1562` gets the order owner (order.owner query)
+- `logic_equal` compares the two addresses
+
+### Pattern 2: Verify Order Progress Node
+
+```json
+{
+  "type": "logic_equal",
+  "nodes": [
+    {
+      "type": "query",
+      "query": 1253,
+      "object": { "identifier": 0, "convert_witness": 100 },
+      "parameters": []
+    },
+    { "type": "identifier", "identifier": 1 }
+  ]
+}
+```
+
+**Explanation:**
+- `query: 1253` gets the current progress node name
+- `convert_witness: 100` (TypeOrderProgress) converts the object for progress query
+- Compares with the expected node name stored at identifier 1
+
+### Pattern 3: Verify Reward Not Claimed
+
+```json
+{
+  "type": "logic_not",
+  "node": {
+    "type": "query_reward_record_exists",
+    "object": { "identifier": 0 },
+    "recipient": { "identifier": 1 },
+    "where": {}
+  }
+}
+```
+
+**Explanation:**
+- `query_reward_record_exists` checks if a reward record exists for the recipient
+- `logic_not` inverts the result (returns true if NO record exists)
+- This verifies the reward has NOT been claimed
+
+### Pattern 4: Combined Validation (Reward Guard)
+
+```json
+{
+  "type": "logic_and",
+  "nodes": [
+    {
+      "type": "logic_equal",
+      "nodes": [
+        {
+          "type": "query",
+          "query": 1253,
+          "object": { "identifier": 0, "convert_witness": 100 },
+          "parameters": []
+        },
+        { "type": "identifier", "identifier": 1 }
+      ]
+    },
+    {
+      "type": "logic_equal",
+      "nodes": [
+        { "type": "context", "context": "Signer" },
+        {
+          "type": "query",
+          "query": 1562,
+          "object": { "identifier": 0 },
+          "parameters": []
+        }
+      ]
+    },
+    {
+      "type": "logic_not",
+      "node": {
+        "type": "query_reward_record_exists",
+        "object": { "identifier": 2 },
+        "recipient": { "identifier": 3 },
+        "where": {}
+      }
+    }
+  ]
+}
+```
+
+**Explanation:**
+This is a complete Reward Guard that verifies:
+1. Order is at expected progress node (e.g., "delivered")
+2. Transaction signer is the order owner
+3. Order has NOT claimed the reward yet
+
+## Query Instruction Reference
+
+| Query ID | Name | Description | Parameters | Returns |
+|----------|------|-------------|------------|---------|
+| 1253 | order.progress.node | Get current progress node name | None | String |
+| 1562 | order.owner | Get order owner address | None | Address |
+| 1563 | order.service | Get order service address | None | Address |
+| 1564 | order.payer | Get order payer address | None | Address |
+
+## Witness Types
+
+| Witness ID | Name | Description |
+|------------|------|-------------|
+| 100 | TypeOrderProgress | Access order progress data |
+| 200 | TypeOrder | Access order data |
+
+## Node Return Types
+
+### Logic Nodes (Return Bool)
+- `logic_and`, `logic_or`, `logic_not`
+- `logic_equal`, `logic_as_u256_equal`
+- `logic_as_u256_greater`, `logic_as_u256_lesser`
+- `logic_as_u256_greater_or_equal`, `logic_as_u256_lesser_or_equal`
+- `logic_string_contains`, `logic_string_nocase_contains`, `logic_string_nocase_equal`
+
+### Calculation Nodes (Return Numeric)
+- `calc_number_add`, `calc_number_subtract`, `calc_number_multiply`, `calc_number_divide`, `calc_number_mod` → U256
+- `calc_string_length` → U64
+- `calc_string_contains`, `calc_string_nocase_contains`, `calc_string_nocase_equal` → Bool
+- `calc_string_indexof`, `calc_string_nocase_indexof` → U64
+
+### Conversion Nodes
+- `convert_number_address` → Address
+- `convert_address_number` → U64
+- `convert_number_string` → String
+- `convert_string_number` → U256
+- `convert_safe_u8`, `convert_safe_u16`, `convert_safe_u32`, `convert_safe_u64`, `convert_safe_u128`, `convert_safe_u256` → Respective type
+
+### Query Nodes (Return Varies)
+- `query` → Depends on query instruction
+- `query_reward_record_find`, `query_reward_record_count` → U64
+- `query_reward_record_exists` → Bool
+- `query_progress_history_find`, `query_progress_history_session_find`, `query_progress_history_session_forward_find` → U64
+- `query_progress_history_session_count`, `query_progress_history_session_forward_count`, `query_progress_history_session_forward_retained_submission_count` → U64
+
+### Context Nodes
+- `context: Signer` → Address
+- `context: Clock` → U64 (timestamp)
+- `context: Guard` → Address
+
+### Vector Nodes
+- `vec_length` → U64
+- `vec_contains_bool`, `vec_contains_address`, `vec_contains_string`, `vec_contains_string_nocase`, `vec_contains_number` → Bool
+
+## Best Practices
+
+1. **Root node must return Bool**: Always use a logic node (logic_and, logic_or) as the root.
+
+2. **Use logic_and for multiple conditions**: Most common pattern for combining validations.
+
+3. **Check node return types**: Ensure child nodes return the expected type for the parent node.
+   - Logic nodes expect Bool children
+   - Calculation nodes expect numeric children
+   - Comparison nodes expect matching types
+
+4. **Use identifier references**: Store constants (addresses, strings, numbers) in the Guard table and reference them by identifier.
+
+5. **Query with convert_witness**: When querying object data, use the appropriate witness type to access the data you need.
+
+6. **Handle optional fields**: In where clauses, only include fields you want to filter by. Omitting a field means "don't filter by this field".
+
+## Common Errors
+
+1. **Type mismatch**: Trying to compare incompatible types (e.g., Address with String).
+2. **Missing identifier**: Referencing an identifier that doesn't exist in the Guard table.
+3. **Wrong return type**: Using a non-Bool node as the root or as a child of a logic node.
+4. **Invalid query ID**: Using a query instruction ID that doesn't exist.