n8n-nodes-lifespace 0.1.7 → 0.1.8

package/README.md

@@ -66,7 +66,12 @@ Runtime Discovery determines which Spaces, Record Types, fields, queries, Action
 
 ## Generated Record UX
 
-Create/Update keep scalar fields in n8n Resource Mapper while using native n8n controls for LifeSpace calendar-date fields and supported relations. Single relations use a selector; multi-relations use multi-select. List / Query offers typed filter variants for text, enum, boolean, number, date/time and authorized relations, while retaining the raw legacy filter as an expression/compatibility escape hatch.
+The package deliberately exposes two different projections over the same LifeSpace Runtime Discovery semantics:
+
+- **LifeSpace** is the human-authored workflow node. Create/Update fields are generated through n8n Resource Mapper from the selected Record Type, so field type, required state, enum values, calendar dates and supported single relations determine the control automatically. List / Query exposes semantic predicates such as `Status — Is One Of` or `Due Date — After or Equal` instead of asking the workflow author to choose a filter type first. Multi-value relations keep their dedicated multi-select UX.
+- **LifeSpace Agent Tool** is the native AI Tool surface. Its schema is generated for the model: generic queries expose semantic `field` / `operator` / `value` inputs, and the adapter compiles those inputs to the exact transport names published by LifeSpace. Capability Queries consume the grouped schema published by Runtime Discovery.
+
+The human workflow node is not exposed through `usableAsTool`; this avoids maintaining two competing Agent Tool surfaces with different schema behavior.
 
 The node displays the authorized human-readable `spaceName` when present while continuing to submit the stable `spc_*` ID.
 
@@ -74,16 +79,6 @@ Record Type is the LifeSpace `modelKey` (for example `task`). Design-time option
 
 Calendar-backed models use canonical `capabilityBindings.calendar` field roles instead of Event-specific field names while the node is being configured. Date-only values are normalized to `YYYY-MM-DD`. Create/Update execution does not fetch fresh semantic Discovery solely to produce an adapter-local Calendar conflict error; the canonical mutation goes directly to LifeSpace Core, which remains authoritative for Calendar validation and current authorization.
 
-## AI Agent Tool
-
-`LifeSpace Tool` is the metadata-driven AI Agent sub-node. Configure one fixed Space, Record Type and semantic operation per Tool instance, then connect multiple instances to the same n8n AI Agent. The Tool name, default description and structured AI input schema are generated from LifeSpace Progressive Runtime Discovery; hand-written descriptions are optional.
-
-- Query exposes published search/filter/comparison/local-date-window/sort/pagination semantics. Capability Query mode exposes only the capability-owned parameters and ordering that LifeSpace explicitly publishes; generic-facet composition stays narrowed until LifeSpace #228 defines it.
-- Create/Update schemas come from writable Model fields. Required fields with LifeSpace defaults are optional AI inputs, and fields the AI omits are absent from the outgoing request rather than synthesized as empty/null placeholders.
-- Delete and Action hide optimistic-concurrency `version` from the AI. The Adapter reads the current record version when required and Core remains the final authorization/concurrency/semantic authority.
-- No Task/Event/Wish-specific Tool nodes or field maps are shipped. New models become available through Discovery without source changes.
-- The ordinary `LifeSpace` workflow node remains `usableAsTool` for manually configured `$fromAI(...)` workflows, but `LifeSpace Tool` is the canonical path when the AI should receive the complete dynamic LifeSpace schema.
-
 ## LifeSpace contract compatibility
 
 This package follows the current LifeSpace Core Kernel `0.35.0` contract family. It consumes Runtime/Discovery semantics only; Eventing configuration and webhook delivery semantics are owned independently by Integration/Eventing `0.1.0`.
@@ -140,16 +135,16 @@ Examples:
 {{$vars.lifeSpaceRecordType}}
 ```
 
-Discovery-backed selectors such as **Space**, **Filter Field**, **Sort Field** and **Action** support the normal n8n pattern: choose a value from the list, or switch the parameter to an expression and provide the corresponding stable ID/key. **Record Type** stores the plain LifeSpace `modelKey`, so a LifeSpace Trigger can feed a Record node directly without a mapping step or an extra Discovery request.
+Discovery-backed selectors such as **Space**, **Sort Field** and **Action** support the normal n8n pattern: choose a value from the list, or switch the parameter to an expression and provide the corresponding stable ID/key. **Record Type** stores the plain LifeSpace `modelKey`, so a LifeSpace Trigger can feed a Record node directly without a mapping step or an extra Discovery request.
 
-The same applies to ordinary values such as Record ID, Search, Filter Value, Return All, Limit, Sort Direction, Cursor, explicit Version, API Method, API Path and JSON Body.
+The same applies to ordinary values such as Record ID, Search, Return All, Limit, Sort Direction, Cursor, explicit Version, API Method, API Path and JSON Body.
 
 Two boundaries are intentional:
 
 - **Resource** and **Operation** are structural node controls and do not accept expressions because they determine which parameter schema and execution path the node has.
-- **Fields** and **Action Input** use n8n's `resourceMapper`. The mapper container is structural, but each generated field value inside it remains expression-capable. This includes relation-backed field values: the UI can offer authorized options while an expression can still supply a stable relation ID or ID list.
+- **Fields**, **Filters**, Capability Query parameters and **Action Input** are generated from Runtime Discovery. Their mapper containers are structural, while generated values remain expression-capable.
 
-For **Filters** and **Sorts**, add the required rows in the node UI and use expressions inside each row's Field/Operator/Value or Field/Direction inputs. The number of rows is treated as workflow structure rather than per-item data. This avoids relying on whole-array expressions for n8n `fixedCollection` parameters.
+In Standard Query, **Filters** is a Discovery-driven Resource Mapper. Adding a filter selects a published semantic predicate such as `Due Date — Before`; n8n then renders the value control from the underlying field type. **Sorts** remains an ordered structural list because sort priority is part of workflow structure rather than per-item data.
 
 If **Record Type** itself varies per input item and those Record Types have different schemas, one discovery-generated mapper cannot safely represent every possible schema at design time. In that case, branch to separate LifeSpace nodes per schema or use **API Request** for a deliberately fully dynamic request.
 
@@ -188,7 +183,7 @@ LifeSpace server defaults are authoritative. A field that is `required` but has
 
 For example, lifecycle state such as Task status can remain server/Action-owned instead of being manually entered by the workflow author.
 
-When Runtime Discovery advertises relation semantics, supported `person`, `person_list`, `record` and `record_list` fields are rendered from the current authorized `{ id, label }` target projection instead of asking the workflow author to type raw identifiers. The displayed value is the canonical LifeSpace reference label, while the workflow payload still stores and submits the stable target ID.
+When Runtime Discovery advertises relation semantics, supported single-value `person` / `record` fields are rendered as selectors from the current authorized `{ id, label }` target projection. Multi-value relations retain the dedicated multi-select control rather than falling back to n8n Resource Mapper's generic JSON array editor. The displayed value is the canonical LifeSpace reference label, while the workflow payload still stores and submits the stable target ID.
 
 Older compatible Discovery responses without relation lookup metadata retain the raw-ID field behavior. The adapter never guesses record labels from conventional fields such as `name`, `title` or `summary`.
 
@@ -208,19 +203,18 @@ If a workflow intentionally needs to bind a known version, add **Concurrency Opt
 
 ### List / Query
 
-The normal UI supports:
+**Query Type** separates ordinary record query UX from capability-owned query semantics:
+
+- **Records** is the normal query surface and exposes optional **Search**, Discovery-driven semantic **Filters**, optional **Advanced Local Date Windows**, generic **Sorts**, **Return All** and **Limit**;
+- each Filter entry represents an allowed field/operator pair published by LifeSpace, for example `Status — Is One Of`, `Due Date — Before` or `Created At — After or Equal`; the adapter compiles the selected semantic predicate to the exact transport parameter published by Discovery;
+- **Capability Query** is offered only when the selected Record Type publishes `query.capabilityQueries`; its selector, parameters and ordering are loaded from Runtime Discovery;
+- **Return All** follows `nextCursor` automatically, while **Limit** bounds a single-page query.
 
-- optional **Search**;
-- one or more typed **Filters**;
-- Discovery-driven explicit **Number Comparison** and **Date / Time Comparison** rows using the exact LifeSpace-published operator transport;
-- generic **Local Date Windows** for datetime fields advertised by Time Semantics, including envelope `createdAt` / `updatedAt`, with local dates + IANA timezone sent unchanged to Core;
-- optional grouped **Semantic Query** input generated from `query.capabilityQueries` (for example `calendar.window`) plus its published semantic ordering;
-- **Return All** to follow `nextCursor` automatically;
-- **Limit** when Return All is disabled.
+Advanced Local Date Windows are shown separately because a local calendar window is a structured field/start/end/timezone input rather than a scalar predicate. The adapter sends the published date-window parameter names and IANA timezone unchanged; Core owns timezone/DST conversion. Existing persisted legacy `exact/from/to` filters preserve the inclusive `To` behavior.
 
-The adapter never derives explicit comparison parameter names from field naming and never converts local calendar windows to UTC. Those transport names and timezone/DST semantics come from LifeSpace Runtime Semantic Detail. Existing `exact/from/to` filters remain available as compatibility UI and preserve the legacy inclusive `To` behavior.
+Generic Search/Filters/Sorts are intentionally hidden in Capability Query mode until LifeSpace publishes machine-readable facet-composability metadata. This prevents the adapter from guessing which generic parameters may be mixed with a grouped capability query.
 
-Use **Sorts → Add Sort** to add zero or more sort criteria in priority order. Sortable model fields use authoritative `title` metadata from Runtime Discovery, while envelope fields such as `createdAt` / `updatedAt` are offered only when Discovery advertises them. Multiple criteria are sent as ordered repeated `sort=field:direction` query parameters.
+Use **Sorts → Add Sort** in Records mode to add zero or more sort criteria in priority order. Sortable model fields use authoritative `title` metadata from Runtime Discovery, while envelope fields such as `createdAt` / `updatedAt` are offered only when Discovery advertises them. Multiple criteria are sent as ordered repeated `sort=field:direction` query parameters.
 
 Advanced **Options** contain manual **Cursor** as an escape hatch.
 
@@ -248,6 +242,30 @@ Paths are relative to the configured API Base URL, for example:
 
 Use normal Record operations when possible because they benefit from Runtime Discovery metadata and n8n-specific UX.
 
+## Use the LifeSpace Agent Tool
+
+Use **LifeSpace Agent Tool** when connecting LifeSpace to an n8n AI Agent. This is a separate native AiTool surface rather than the human workflow node running through `usableAsTool`.
+
+Configure the Tool's structural scope — Space, Record Type and operation — in the node. The Tool then derives its model-facing name, description and input schema from Runtime Discovery, so multiple LifeSpace Tools can distinguish their configured purpose without requiring handwritten descriptions.
+
+For Generic Query, the model receives semantic inputs such as:
+
+```json
+{
+  "search": "food",
+  "filters": [
+    { "field": "status", "operator": "in", "value": ["todo"] },
+    { "field": "dueDate", "operator": "gte", "value": "2026-09-13" }
+  ],
+  "sort": [{ "field": "dueDate", "direction": "asc" }],
+  "limit": 20
+}
+```
+
+The adapter validates those field/operator pairs against Discovery and compiles them to the exact LifeSpace query transport. The model does not need to know transport names such as `dueDate.gte`. Local date windows are likewise semantic inputs and Core remains responsible for timezone/DST conversion.
+
+Create/Update schemas are generated from writable model fields. Optional fields that the model does not provide are omitted rather than synthesized as empty values. Actions and Capability Queries remain metadata-driven, and adding a future Record Type does not require a model-specific `create_*` or `query_*` node implementation.
+
 ## Use the LifeSpace Trigger
 
 The **LifeSpace Trigger** receives signed LifeSpace Domain Event webhooks.
@@ -283,11 +301,12 @@ Webhook Endpoint / Event Subscription creation is intentionally not performed by
 
 - **LifeSpace API** credential for API authentication and Runtime Discovery;
 - **LifeSpace Webhook Signing** credential for endpoint-scoped inbound HMAC verification;
-- **LifeSpace** node with discovery-driven Record operations plus advanced API Request;
+- **LifeSpace** human workflow node with Discovery-driven Record operations plus advanced API Request;
+- **LifeSpace Agent Tool** native AiTool with Discovery-driven semantic schemas;
 - **LifeSpace Trigger** with signed multi-Record-Type Domain Event filtering;
-- dynamic Space, Record Type, field, relation target, query, Action and Action Input UI based on progressive Runtime Discovery.
+- shared thin adapter projection from LifeSpace Runtime Discovery into human n8n controls and model-facing Tool schemas.
 
-LifeSpace remains authoritative for validation, authorization, defaults, Mutation Authority, Action semantics, relation semantics and event contracts. Runtime Discovery and Relation Target Lookup are current capability/reference projections, not execution-authorization proofs.
+LifeSpace remains authoritative for validation, authorization, defaults, Mutation Authority, Action semantics, query/time semantics, relation semantics and event contracts. Runtime Discovery and Relation Target Lookup are current capability/reference projections, not execution-authorization proofs.
 
 ## Architecture boundary
 
@@ -295,6 +314,8 @@ LifeSpace is the source of truth for Identity, Authority, Shared Reality semanti
 
 LifeSpace does not depend on n8n. n8n is one optional orchestration/integration runtime consuming LifeSpace APIs and events.
 
+The human Workflow node and native Agent Tool are separate presentation projections over the same LifeSpace semantics. Shared code in this package only translates Discovery into n8n-specific UI/schema/transport; it does not redefine domain rules.
+
 The adapter does not use privileged model-admin endpoints for ordinary workflow discovery and does not copy Model Definitions into this repository.
 
 ## Development
@@ -337,4 +358,4 @@ The adapter now consumes generic `person`, `person_list`, `record` and `record_l
 
 ## License
 
-MIT
+MIT

package/dist/nodes/LifeSpace/LifeSpace.node.d.ts

@@ -20,6 +20,7 @@ export declare class LifeSpace implements INodeType {
             getTemporalComparisonFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getComparisonOperatorsForCurrentField(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getLocalDateWindowFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getQueryModes(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getCapabilityQueries(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getSemanticSorts(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getPersonFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;

package/dist/nodes/LifeSpace/LifeSpace.node.js

@@ -171,26 +171,40 @@ function normalizeActionInput(context, itemIndex, value, fields) {
     return result;
 }
 function queryParameters(context, itemIndex, limit, cursorOverride) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
     const qs = {};
-    const search = String(context.getNodeParameter('search', itemIndex, '')).trim();
+    const configuredQueryMode = String((_a = context.getNodeParameter('queryMode', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+    const legacyCapabilityQueryKey = String((_b = context.getNodeParameter('semanticQueryKey', itemIndex, '')) !== null && _b !== void 0 ? _b : '').trim();
+    const rawCapabilityQueryInput = mappedValue(context, itemIndex, 'semanticQueryInput');
+    const rawCapabilitySort = String((_c = context.getNodeParameter('semanticSort', itemIndex, '')) !== null && _c !== void 0 ? _c : '').trim();
+    const hasLegacyCapabilityConfiguration = legacyCapabilityQueryKey !== ''
+        || Object.keys(rawCapabilityQueryInput).length > 0
+        || rawCapabilitySort !== '';
+    const queryMode = configuredQueryMode || (hasLegacyCapabilityConfiguration ? 'capability' : 'standard');
+    const useStandardQuery = queryMode !== 'capability';
+    const useCapabilityQuery = queryMode === 'capability';
+    const search = useStandardQuery ? String(context.getNodeParameter('search', itemIndex, '')).trim() : '';
     const options = context.getNodeParameter('options', itemIndex, {});
-    const configuredSorts = context.getNodeParameter('sorts.sort', itemIndex, []);
-    const semanticSort = String((_a = context.getNodeParameter('semanticSort', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
-    const legacySortField = String((_b = options.sortField) !== null && _b !== void 0 ? _b : '').trim();
-    const legacySortDirection = String((_c = options.sortDirection) !== null && _c !== void 0 ? _c : 'desc').trim();
-    const configuredCursor = String((_d = options.cursor) !== null && _d !== void 0 ? _d : '').trim();
+    const configuredSorts = useStandardQuery
+        ? context.getNodeParameter('sorts.sort', itemIndex, [])
+        : [];
+    const semanticSort = useCapabilityQuery ? rawCapabilitySort : '';
+    const legacySortField = useStandardQuery ? String((_d = options.sortField) !== null && _d !== void 0 ? _d : '').trim() : '';
+    const legacySortDirection = String((_e = options.sortDirection) !== null && _e !== void 0 ? _e : 'desc').trim();
+    const configuredCursor = String((_f = options.cursor) !== null && _f !== void 0 ? _f : '').trim();
     const cursor = cursorOverride !== null && cursorOverride !== void 0 ? cursorOverride : configuredCursor;
-    const filters = context.getNodeParameter('filters.filter', itemIndex, []);
+    const filters = useStandardQuery
+        ? context.getNodeParameter('filters.filter', itemIndex, [])
+        : [];
     if (search)
         qs.q = search;
     const orderedSorts = [];
     const usedSortFields = new Set();
     for (const sort of configuredSorts) {
-        const field = String((_e = sort.field) !== null && _e !== void 0 ? _e : '').trim();
+        const field = String((_g = sort.field) !== null && _g !== void 0 ? _g : '').trim();
         if (!field)
             continue;
-        const direction = String((_f = sort.direction) !== null && _f !== void 0 ? _f : 'asc').trim();
+        const direction = String((_h = sort.direction) !== null && _h !== void 0 ? _h : 'asc').trim();
         if (direction !== 'asc' && direction !== 'desc') {
             throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Sort direction for ${field} must be asc or desc`, { itemIndex });
         }
@@ -227,37 +241,39 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
         setQueryParameter(key, value);
     };
     for (const filter of filters) {
-        const field = String((_g = filter.field) !== null && _g !== void 0 ? _g : '').trim();
-        const value = String((_h = filter.value) !== null && _h !== void 0 ? _h : '');
-        const operator = (_j = filter.operator) !== null && _j !== void 0 ? _j : 'exact';
+        const field = String((_j = filter.field) !== null && _j !== void 0 ? _j : '').trim();
+        const value = String((_k = filter.value) !== null && _k !== void 0 ? _k : '');
+        const operator = (_l = filter.operator) !== null && _l !== void 0 ? _l : 'exact';
         if (field && value !== '')
             setFilter(field, operator, value);
     }
-    const typedFilters = context.getNodeParameter('filters', itemIndex, {});
-    for (const row of ((_k = typedFilters.text) !== null && _k !== void 0 ? _k : [])) {
-        const field = String((_l = row.field) !== null && _l !== void 0 ? _l : '').trim();
+    const typedFilters = useStandardQuery
+        ? context.getNodeParameter('filters', itemIndex, {})
+        : {};
+    for (const row of ((_m = typedFilters.text) !== null && _m !== void 0 ? _m : [])) {
+        const field = String((_o = row.field) !== null && _o !== void 0 ? _o : '').trim();
         if (field && row.value !== undefined && row.value !== '')
             setFilter(field, 'exact', String(row.value));
     }
-    for (const row of ((_m = typedFilters.enum) !== null && _m !== void 0 ? _m : [])) {
-        const field = String((_o = row.field) !== null && _o !== void 0 ? _o : '').trim();
+    for (const row of ((_p = typedFilters.enum) !== null && _p !== void 0 ? _p : [])) {
+        const field = String((_q = row.field) !== null && _q !== void 0 ? _q : '').trim();
         const values = Array.isArray(row.values) ? row.values.map(String).filter(Boolean) : [];
         if (field && values.length)
             setFilter(field, 'exact', values.join(','));
     }
-    for (const row of ((_p = typedFilters.boolean) !== null && _p !== void 0 ? _p : [])) {
-        const field = String((_q = row.field) !== null && _q !== void 0 ? _q : '').trim();
+    for (const row of ((_r = typedFilters.boolean) !== null && _r !== void 0 ? _r : [])) {
+        const field = String((_s = row.field) !== null && _s !== void 0 ? _s : '').trim();
         if (field)
             setFilter(field, 'exact', Boolean(row.value));
     }
-    for (const row of ((_r = typedFilters.number) !== null && _r !== void 0 ? _r : [])) {
-        const field = String((_s = row.field) !== null && _s !== void 0 ? _s : '').trim();
+    for (const row of ((_t = typedFilters.number) !== null && _t !== void 0 ? _t : [])) {
+        const field = String((_u = row.field) !== null && _u !== void 0 ? _u : '').trim();
         const value = Number(row.value);
         if (field && Number.isFinite(value))
-            setFilter(field, (_t = row.operator) !== null && _t !== void 0 ? _t : 'exact', value);
+            setFilter(field, (_v = row.operator) !== null && _v !== void 0 ? _v : 'exact', value);
     }
-    for (const row of ((_u = typedFilters.temporal) !== null && _u !== void 0 ? _u : [])) {
-        const encoded = String((_v = row.field) !== null && _v !== void 0 ? _v : '').trim();
+    for (const row of ((_w = typedFilters.temporal) !== null && _w !== void 0 ? _w : [])) {
+        const encoded = String((_x = row.field) !== null && _x !== void 0 ? _x : '').trim();
         if (!encoded || row.value === undefined || row.value === '')
             continue;
         const separator = encoded.indexOf(':');
@@ -266,24 +282,24 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
         const raw = String(row.value);
         const value = fieldType === 'date' ? dateOnlyValue(context, itemIndex, raw, field) : raw;
         if (value !== null)
-            setFilter(field, (_w = row.operator) !== null && _w !== void 0 ? _w : 'exact', value);
+            setFilter(field, (_y = row.operator) !== null && _y !== void 0 ? _y : 'exact', value);
     }
-    for (const row of ((_x = typedFilters.person) !== null && _x !== void 0 ? _x : [])) {
-        const field = String((_y = row.field) !== null && _y !== void 0 ? _y : '').trim();
-        const target = String((_z = row.target) !== null && _z !== void 0 ? _z : '').trim();
+    for (const row of ((_z = typedFilters.person) !== null && _z !== void 0 ? _z : [])) {
+        const field = String((_0 = row.field) !== null && _0 !== void 0 ? _0 : '').trim();
+        const target = String((_1 = row.target) !== null && _1 !== void 0 ? _1 : '').trim();
         if (field && target)
             setFilter(field, 'exact', target);
     }
-    for (const row of ((_0 = typedFilters.numberComparison) !== null && _0 !== void 0 ? _0 : [])) {
+    for (const row of ((_2 = typedFilters.numberComparison) !== null && _2 !== void 0 ? _2 : [])) {
         const field = comparisonFieldParts(row.field).field;
-        const parameter = String((_1 = row.parameter) !== null && _1 !== void 0 ? _1 : '').trim();
+        const parameter = String((_3 = row.parameter) !== null && _3 !== void 0 ? _3 : '').trim();
         const value = Number(row.value);
         if (field && parameter && Number.isFinite(value))
             setQueryParameter(parameter, value);
     }
-    for (const row of ((_2 = typedFilters.temporalComparison) !== null && _2 !== void 0 ? _2 : [])) {
+    for (const row of ((_4 = typedFilters.temporalComparison) !== null && _4 !== void 0 ? _4 : [])) {
         const { field, valueType } = comparisonFieldParts(row.field);
-        const parameter = String((_3 = row.parameter) !== null && _3 !== void 0 ? _3 : '').trim();
+        const parameter = String((_5 = row.parameter) !== null && _5 !== void 0 ? _5 : '').trim();
         if (!field || !parameter || row.value === undefined || row.value === '')
             continue;
         const raw = String(row.value);
@@ -291,18 +307,23 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
         if (value !== null)
             setQueryParameter(parameter, value);
     }
-    const localDateWindows = context.getNodeParameter('localDateWindows.window', itemIndex, []);
+    const localDateWindows = useStandardQuery
+        ? [
+            ...((_6 = typedFilters.localDateWindow) !== null && _6 !== void 0 ? _6 : []),
+            ...context.getNodeParameter('localDateWindows.window', itemIndex, []),
+        ]
+        : [];
     for (const row of localDateWindows) {
         const selector = decodeLocalDateWindowSelector(row.field);
         if (!selector) {
-            if (String((_4 = row.field) !== null && _4 !== void 0 ? _4 : '').trim()) {
+            if (String((_7 = row.field) !== null && _7 !== void 0 ? _7 : '').trim()) {
                 throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Local Date Window selector is invalid. Re-select the field from Runtime Discovery.', { itemIndex });
             }
             continue;
         }
         const dateStart = dateOnlyValue(context, itemIndex, row.dateStart, selector.field);
         const dateEndExclusive = dateOnlyValue(context, itemIndex, row.dateEndExclusive, selector.field);
-        const timezone = String((_5 = row.timezone) !== null && _5 !== void 0 ? _5 : '').trim();
+        const timezone = String((_8 = row.timezone) !== null && _8 !== void 0 ? _8 : '').trim();
         if (dateStart !== null)
             setQueryParameter(selector.dateStartParameter, dateStart);
         if (dateEndExclusive !== null)
@@ -310,12 +331,12 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
         if (timezone)
             setQueryParameter(selector.timezoneParameter, timezone);
     }
-    const semanticQueryInput = mappedValue(context, itemIndex, 'semanticQueryInput');
+    const semanticQueryInput = useCapabilityQuery ? rawCapabilityQueryInput : {};
     for (const [parameter, value] of Object.entries(semanticQueryInput)) {
         if (value === null || value === undefined || value === '')
             continue;
         if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Semantic Query parameter ${parameter} must be a scalar value`, { itemIndex });
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Capability Query parameter ${parameter} must be a scalar value`, { itemIndex });
         }
         setQueryParameter(parameter, value);
     }
@@ -647,14 +668,21 @@ class LifeSpace {
                             ] }],
                 },
                 {
-                    displayName: 'Search', name: 'search', type: 'string', default: '',
+                    displayName: 'Query Mode Name or ID', name: 'queryMode', type: 'options', noDataExpression: true,
+                    typeOptions: { loadOptionsMethod: 'getQueryModes', loadOptionsDependsOn: ['spaceId', 'recordType'] },
+                    options: [], default: 'standard',
                     displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
+                    description: 'Standard Query is always available. Capability Query is offered only when the selected Record Type publishes a grouped capability query through Runtime Discovery. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Search', name: 'search', type: 'string', default: '',
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'], queryMode: ['standard'] } },
                     description: 'Full-text search across fields declared searchable by LifeSpace. Leave empty to disable search.',
                 },
                 {
                     displayName: 'Filters', name: 'filters', type: 'fixedCollection', default: {},
                     placeholder: 'Add Filter', typeOptions: { multipleValues: true },
-                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'], queryMode: ['standard'] } },
                     options: [
                         { displayName: 'Text Filter', name: 'text', values: [
                                 { displayName: 'Field Name or ID', name: 'field', type: 'options', description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>', typeOptions: { loadOptionsMethod: 'getTextFilterableFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
@@ -688,6 +716,12 @@ class LifeSpace {
                                 { displayName: 'Operator Name or ID', name: 'parameter', type: 'options', description: 'Uses the exact explicit comparison transport advertised by LifeSpace. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.', typeOptions: { loadOptionsMethod: 'getComparisonOperatorsForCurrentField', loadOptionsDependsOn: ['spaceId', 'recordType', '&field'] }, options: [], default: '', required: true },
                                 { displayName: 'Value', name: 'value', type: 'dateTime', default: '', required: true },
                             ] },
+                        { displayName: 'Local Date Window', name: 'localDateWindow', values: [
+                                { displayName: 'Field Name or ID', name: 'field', type: 'options', typeOptions: { loadOptionsMethod: 'getLocalDateWindowFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true, description: 'Choose a datetime field whose published Time Semantics includes a local-date-window transport. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.' },
+                                { displayName: 'Start Date', name: 'dateStart', type: 'dateTime', default: '', required: true, description: 'Inclusive local calendar start date. The adapter sends YYYY-MM-DD and does not calculate UTC boundaries.' },
+                                { displayName: 'End Date (Exclusive)', name: 'dateEndExclusive', type: 'dateTime', default: '', required: true, description: 'Exclusive local calendar end date' },
+                                { displayName: 'Viewing Timezone', name: 'timezone', type: 'string', default: '', required: true, placeholder: 'Europe/Amsterdam', description: 'IANA timezone passed unchanged to LifeSpace Core' },
+                            ] },
                         { displayName: 'Person Filter', name: 'person', values: [
                                 { displayName: 'Field Name or ID', name: 'field', type: 'options', description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>', typeOptions: { loadOptionsMethod: 'getPersonFilterableFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
                                 { displayName: 'Person Name or ID', name: 'target', type: 'options', description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>', typeOptions: { loadOptionsMethod: 'getRelationTargetsForCurrentField', loadOptionsDependsOn: ['spaceId', 'recordType', '&field'] }, options: [], default: '', required: true },
@@ -700,43 +734,33 @@ class LifeSpace {
                     ],
                 },
                 {
-                    displayName: 'Local Date Windows', name: 'localDateWindows', type: 'fixedCollection', default: {},
-                    placeholder: 'Add Local Date Window', typeOptions: { multipleValues: true },
-                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
-                    options: [{ displayName: 'Window', name: 'window', values: [
-                                { displayName: 'Field Name or ID', name: 'field', type: 'options', typeOptions: { loadOptionsMethod: 'getLocalDateWindowFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true, description: 'Only datetime fields whose published comparison semantics include a local-date-window transport are offered. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.' },
-                                { displayName: 'Start Date', name: 'dateStart', type: 'dateTime', default: '', required: true, description: 'Inclusive local calendar start date. The adapter submits YYYY-MM-DD and does not calculate UTC boundaries.' },
-                                { displayName: 'End Date (Exclusive)', name: 'dateEndExclusive', type: 'dateTime', default: '', required: true, description: 'Exclusive local calendar end date' },
-                                { displayName: 'Viewing Timezone', name: 'timezone', type: 'string', default: '', required: true, placeholder: 'Europe/Amsterdam', description: 'IANA timezone passed unchanged to LifeSpace Core' },
-                            ] }],
-                },
-                {
-                    displayName: 'Semantic Query Name or ID', name: 'semanticQueryKey', type: 'options',
+                    displayName: 'Capability Query Name or ID', name: 'semanticQueryKey', type: 'options', noDataExpression: true,
                     typeOptions: { loadOptionsMethod: 'getCapabilityQueries', loadOptionsDependsOn: ['spaceId', 'recordType'] },
-                    options: [], default: '',
-                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
-                    description: 'Optional grouped capability query published by LifeSpace, for example Calendar Window. The adapter does not hard-code Event fields. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    options: [], default: '', required: true,
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'], queryMode: ['capability'] } },
+                    description: 'Choose a grouped capability query published by the selected LifeSpace Record Type. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
                 },
                 {
-                    displayName: 'Semantic Query Input', name: 'semanticQueryInput', type: 'resourceMapper',
+                    displayName: 'Capability Query Parameters', name: 'semanticQueryInput', type: 'resourceMapper',
                     default: { mappingMode: 'defineBelow', value: null }, noDataExpression: true,
                     typeOptions: {
                         loadOptionsDependsOn: ['spaceId', 'recordType', 'semanticQueryKey'],
                         resourceMapper: {
                             resourceMapperMethod: 'getSemanticQueryInputFields', mode: 'add',
-                            fieldWords: { singular: 'parameter', plural: 'parameters' }, addAllFields: true, supportAutoMap: false,
-                            noFieldsError: 'Choose a Semantic Query to load its LifeSpace-published parameters.',
+                            fieldWords: { singular: 'query parameter', plural: 'query parameters' },
+                            addAllFields: true, supportAutoMap: false,
+                            noFieldsError: 'Choose a Capability Query to load its LifeSpace-published parameters.',
                         },
                     },
-                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
-                    description: 'Parameters are projected directly from query.capabilityQueries. Calendar local dates/timezone are sent to Core unchanged; Core owns overlap and DST semantics.',
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'], queryMode: ['capability'] } },
+                    description: 'Parameters are projected directly from query.capabilityQueries. Local dates/timezone are sent to Core unchanged; Core owns overlap and DST semantics.',
                 },
                 {
-                    displayName: 'Semantic Sort Name or ID', name: 'semanticSort', type: 'options',
+                    displayName: 'Capability Sort Name or ID', name: 'semanticSort', type: 'options',
                     typeOptions: { loadOptionsMethod: 'getSemanticSorts', loadOptionsDependsOn: ['spaceId', 'recordType', 'semanticQueryKey'] },
                     options: [], default: '',
-                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
-                    description: 'Optional capability-specific sort published with the selected Semantic Query. Do not combine with field Sorts. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'], queryMode: ['capability'] } },
+                    description: 'Optional capability-specific ordering published with the selected Capability Query. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
                 },
                 {
                     displayName: 'Return All', name: 'returnAll', type: 'boolean', default: false,
@@ -752,7 +776,7 @@ class LifeSpace {
                 {
                     displayName: 'Sorts', name: 'sorts', type: 'fixedCollection', default: {},
                     placeholder: 'Add Sort', typeOptions: { multipleValues: true },
-                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'], queryMode: ['standard'] } },
                     options: [{ displayName: 'Sort', name: 'sort', values: [
                                 { displayName: 'Field Name or ID', name: 'field', type: 'options', typeOptions: { loadOptionsMethod: 'getSortableFields' }, options: [], default: '', required: true, description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>' },
                                 { displayName: 'Direction', name: 'direction', type: 'options', options: [{ name: 'Ascending', value: 'asc' }, { name: 'Descending', value: 'desc' }], default: 'asc' },
@@ -927,6 +951,27 @@ class LifeSpace {
                         };
                     });
                 },
+                async getQueryModes() {
+                    var _a;
+                    const modes = [{
+                            name: 'Standard Query',
+                            value: 'standard',
+                            description: 'Search, filters, comparisons, local-date windows, and generic sorting',
+                        }];
+                    try {
+                        const selected = await optionModel(this);
+                        if (((_a = selected === null || selected === void 0 ? void 0 : selected.model.query.capabilityQueries) !== null && _a !== void 0 ? _a : []).length > 0) {
+                            modes.push({
+                                name: 'Capability Query',
+                                value: 'capability',
+                                description: 'Use one grouped query contract published by a LifeSpace Capability',
+                            });
+                        }
+                    }
+                    catch {
+                    }
+                    return modes;
+                },
                 async getCapabilityQueries() {
                     var _a;
                     const selected = await optionModel(this);