n8n-nodes-lifespace 0.1.6 → 0.1.7

package/README.md

@@ -74,9 +74,19 @@ 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.32.0` contract family. It consumes Runtime/Discovery semantics only; Eventing configuration and webhook delivery semantics are owned independently by Integration/Eventing `0.1.0`.
+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`.
 
 The UX depends on these Kernel capabilities:
 
@@ -95,6 +105,9 @@ The UX depends on these Kernel capabilities:
 - `0.30.0`: explicit paginated Change History collection and Model Control Plane ownership split;
 - `0.31.0`: Integration/Eventing wire representation moves to the independent Integration/Eventing `0.1.0` contract while Core remains the Runtime authority.
 - `0.32.0`: `modelKey` becomes the sole Runtime address and canonical CRUD/Action paths move under `/models/{modelKey}/records`.
+- `0.33.0`: canonical structural `timeRanges` become available in progressive semantic detail without implying an overlap query API.
+- `0.34.0`: explicit `eq/lt/lte/gt/gte` comparison transports, first-class `createdAt` / `updatedAt` envelope comparisons and Core-owned datetime local-date-window conversion become discoverable.
+- `0.35.0`: grouped `query.capabilityQueries` adds the preferred `calendar.window` viewing-window query with explicit IANA viewing timezone and deterministic mixed all-day/timed ordering.
 
 The adapter prefers the `0.27+` progressive flow while configuring a node:
 
@@ -199,9 +212,14 @@ The normal UI supports:
 
 - 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.
 
+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.
+
 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.
 
 Advanced **Options** contain manual **Cursor** as an escape hatch.

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

@@ -16,6 +16,12 @@ export declare class LifeSpace implements INodeType {
             getBooleanFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getNumericFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getTemporalFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getNumericComparisonFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getTemporalComparisonFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getComparisonOperatorsForCurrentField(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getLocalDateWindowFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getCapabilityQueries(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getSemanticSorts(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getPersonFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getEnumValuesForCurrentFilter(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getSortableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
@@ -23,6 +29,7 @@ export declare class LifeSpace implements INodeType {
         resourceMapping: {
             getRecordFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
             getActionInputFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
+            getSemanticQueryInputFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
         };
     };
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;

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

@@ -9,6 +9,75 @@ const LEGACY_MODEL_ROUTE_TO_KEY = Object.freeze({
     'day-records': 'day_record',
     events: 'event',
 });
+const LOCAL_DATE_WINDOW_SELECTOR_PREFIX = 'lsqw1.';
+const COMPARISON_OPERATOR_LABELS = Object.freeze({
+    eq: 'Equals',
+    lt: 'Less Than',
+    lte: 'Less Than or Equal',
+    gt: 'Greater Than',
+    gte: 'Greater Than or Equal',
+});
+function comparisonFieldParts(value) {
+    const raw = String(value !== null && value !== void 0 ? value : '').trim();
+    const separator = raw.indexOf(':');
+    if (separator <= 0)
+        return { field: raw, valueType: '' };
+    return { valueType: raw.slice(0, separator), field: raw.slice(separator + 1) };
+}
+function encodeLocalDateWindowSelector(comparison) {
+    const window = comparison.localDateWindow;
+    if (!window || comparison.valueType !== 'datetime')
+        return '';
+    return `${LOCAL_DATE_WINDOW_SELECTOR_PREFIX}${Buffer.from(JSON.stringify([
+        comparison.field,
+        comparison.valueType,
+        window.dateStartParameter,
+        window.dateEndExclusiveParameter,
+        window.timezoneParameter,
+    ])).toString('base64url')}`;
+}
+function decodeLocalDateWindowSelector(value) {
+    const raw = String(value !== null && value !== void 0 ? value : '').trim();
+    if (!raw.startsWith(LOCAL_DATE_WINDOW_SELECTOR_PREFIX))
+        return null;
+    try {
+        const decoded = JSON.parse(Buffer.from(raw.slice(LOCAL_DATE_WINDOW_SELECTOR_PREFIX.length), 'base64url').toString('utf8'));
+        if (!Array.isArray(decoded) || decoded.length !== 5 || decoded.some((entry) => typeof entry !== 'string' || !entry))
+            return null;
+        if (decoded[1] !== 'datetime')
+            return null;
+        return {
+            field: decoded[0],
+            valueType: 'datetime',
+            dateStartParameter: decoded[2],
+            dateEndExclusiveParameter: decoded[3],
+            timezoneParameter: decoded[4],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function semanticQueryMapperType(parameter) {
+    if (parameter.type === 'boolean')
+        return 'boolean';
+    if (parameter.type === 'integer' || parameter.type === 'number')
+        return 'number';
+    return 'string';
+}
+function semanticQueryMapperField(parameter) {
+    var _a;
+    return {
+        id: parameter.parameter,
+        displayName: (0, lifespaceDiscovery_1.humanizeKey)(((_a = parameter.role) === null || _a === void 0 ? void 0 : _a.trim()) || parameter.parameter),
+        required: parameter.required === true,
+        defaultMatch: false,
+        canBeUsedToMatch: false,
+        display: true,
+        type: semanticQueryMapperType(parameter),
+        description: `${parameter.type}${parameter.role ? ` · ${parameter.role}` : ''} · LifeSpace query parameter ${parameter.parameter}`,
+    };
+}
 function parseJsonObject(context, itemIndex, value, fieldName) {
     const parsed = typeof value === 'string' ? JSON.parse(value) : value;
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -102,14 +171,15 @@ 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;
+    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;
     const qs = {};
     const search = String(context.getNodeParameter('search', itemIndex, '')).trim();
     const options = context.getNodeParameter('options', itemIndex, {});
     const configuredSorts = context.getNodeParameter('sorts.sort', itemIndex, []);
-    const legacySortField = String((_a = options.sortField) !== null && _a !== void 0 ? _a : '').trim();
-    const legacySortDirection = String((_b = options.sortDirection) !== null && _b !== void 0 ? _b : 'desc').trim();
-    const configuredCursor = String((_c = options.cursor) !== null && _c !== void 0 ? _c : '').trim();
+    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 cursor = cursorOverride !== null && cursorOverride !== void 0 ? cursorOverride : configuredCursor;
     const filters = context.getNodeParameter('filters.filter', itemIndex, []);
     if (search)
@@ -117,10 +187,10 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
     const orderedSorts = [];
     const usedSortFields = new Set();
     for (const sort of configuredSorts) {
-        const field = String((_d = sort.field) !== null && _d !== void 0 ? _d : '').trim();
+        const field = String((_e = sort.field) !== null && _e !== void 0 ? _e : '').trim();
         if (!field)
             continue;
-        const direction = String((_e = sort.direction) !== null && _e !== void 0 ? _e : 'asc').trim();
+        const direction = String((_f = sort.direction) !== null && _f !== void 0 ? _f : '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 });
         }
@@ -130,56 +200,64 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
         usedSortFields.add(field);
         orderedSorts.push(`${field}:${direction}`);
     }
-    if (orderedSorts.length === 1)
+    if (semanticSort && (orderedSorts.length > 0 || legacySortField)) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Semantic Sort cannot be combined with field Sorts', { itemIndex });
+    }
+    if (semanticSort)
+        qs.sort = semanticSort;
+    if (!semanticSort && orderedSorts.length === 1)
         qs.sort = orderedSorts[0];
-    if (orderedSorts.length > 1)
+    if (!semanticSort && orderedSorts.length > 1)
         qs.sort = orderedSorts;
-    if (orderedSorts.length === 0 && legacySortField)
+    if (!semanticSort && orderedSorts.length === 0 && legacySortField)
         qs.sort = `${legacySortField}:${legacySortDirection}`;
     qs.limit = limit;
     if (cursor)
         qs.cursor = cursor;
     const usedKeys = new Set();
-    const setFilter = (field, operator, value) => {
-        const key = operator === 'from' ? `${field}From` : operator === 'to' ? `${field}To` : field;
+    const setQueryParameter = (key, value) => {
         if (usedKeys.has(key)) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Query filter ${key} may be supplied only once`, { itemIndex });
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Query parameter ${key} may be supplied only once`, { itemIndex });
         }
         usedKeys.add(key);
         qs[key] = typeof value === 'boolean' ? String(value) : value;
     };
+    const setFilter = (field, operator, value) => {
+        const key = operator === 'from' ? `${field}From` : operator === 'to' ? `${field}To` : field;
+        setQueryParameter(key, value);
+    };
     for (const filter of filters) {
-        const field = String((_f = filter.field) !== null && _f !== void 0 ? _f : '').trim();
-        const value = String((_g = filter.value) !== null && _g !== void 0 ? _g : '');
-        const operator = (_h = filter.operator) !== null && _h !== void 0 ? _h : 'exact';
+        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';
         if (field && value !== '')
             setFilter(field, operator, value);
     }
     const typedFilters = context.getNodeParameter('filters', itemIndex, {});
-    for (const row of ((_j = typedFilters.text) !== null && _j !== void 0 ? _j : [])) {
-        const field = String((_k = row.field) !== null && _k !== void 0 ? _k : '').trim();
+    for (const row of ((_k = typedFilters.text) !== null && _k !== void 0 ? _k : [])) {
+        const field = String((_l = row.field) !== null && _l !== void 0 ? _l : '').trim();
         if (field && row.value !== undefined && row.value !== '')
             setFilter(field, 'exact', String(row.value));
     }
-    for (const row of ((_l = typedFilters.enum) !== null && _l !== void 0 ? _l : [])) {
-        const field = String((_m = row.field) !== null && _m !== void 0 ? _m : '').trim();
+    for (const row of ((_m = typedFilters.enum) !== null && _m !== void 0 ? _m : [])) {
+        const field = String((_o = row.field) !== null && _o !== void 0 ? _o : '').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 ((_o = typedFilters.boolean) !== null && _o !== void 0 ? _o : [])) {
-        const field = String((_p = row.field) !== null && _p !== void 0 ? _p : '').trim();
+    for (const row of ((_p = typedFilters.boolean) !== null && _p !== void 0 ? _p : [])) {
+        const field = String((_q = row.field) !== null && _q !== void 0 ? _q : '').trim();
         if (field)
             setFilter(field, 'exact', Boolean(row.value));
     }
-    for (const row of ((_q = typedFilters.number) !== null && _q !== void 0 ? _q : [])) {
-        const field = String((_r = row.field) !== null && _r !== void 0 ? _r : '').trim();
+    for (const row of ((_r = typedFilters.number) !== null && _r !== void 0 ? _r : [])) {
+        const field = String((_s = row.field) !== null && _s !== void 0 ? _s : '').trim();
         const value = Number(row.value);
         if (field && Number.isFinite(value))
-            setFilter(field, (_s = row.operator) !== null && _s !== void 0 ? _s : 'exact', value);
+            setFilter(field, (_t = row.operator) !== null && _t !== void 0 ? _t : 'exact', value);
     }
-    for (const row of ((_t = typedFilters.temporal) !== null && _t !== void 0 ? _t : [])) {
-        const encoded = String((_u = row.field) !== null && _u !== void 0 ? _u : '').trim();
+    for (const row of ((_u = typedFilters.temporal) !== null && _u !== void 0 ? _u : [])) {
+        const encoded = String((_v = row.field) !== null && _v !== void 0 ? _v : '').trim();
         if (!encoded || row.value === undefined || row.value === '')
             continue;
         const separator = encoded.indexOf(':');
@@ -188,14 +266,59 @@ 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, (_v = row.operator) !== null && _v !== void 0 ? _v : 'exact', value);
+            setFilter(field, (_w = row.operator) !== null && _w !== void 0 ? _w : 'exact', value);
     }
-    for (const row of ((_w = typedFilters.person) !== null && _w !== void 0 ? _w : [])) {
-        const field = String((_x = row.field) !== null && _x !== void 0 ? _x : '').trim();
-        const target = String((_y = row.target) !== null && _y !== void 0 ? _y : '').trim();
+    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();
         if (field && target)
             setFilter(field, 'exact', target);
     }
+    for (const row of ((_0 = typedFilters.numberComparison) !== null && _0 !== void 0 ? _0 : [])) {
+        const field = comparisonFieldParts(row.field).field;
+        const parameter = String((_1 = row.parameter) !== null && _1 !== void 0 ? _1 : '').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 : [])) {
+        const { field, valueType } = comparisonFieldParts(row.field);
+        const parameter = String((_3 = row.parameter) !== null && _3 !== void 0 ? _3 : '').trim();
+        if (!field || !parameter || row.value === undefined || row.value === '')
+            continue;
+        const raw = String(row.value);
+        const value = valueType === 'date' ? dateOnlyValue(context, itemIndex, raw, field) : raw;
+        if (value !== null)
+            setQueryParameter(parameter, value);
+    }
+    const localDateWindows = 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()) {
+                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();
+        if (dateStart !== null)
+            setQueryParameter(selector.dateStartParameter, dateStart);
+        if (dateEndExclusive !== null)
+            setQueryParameter(selector.dateEndExclusiveParameter, dateEndExclusive);
+        if (timezone)
+            setQueryParameter(selector.timezoneParameter, timezone);
+    }
+    const semanticQueryInput = mappedValue(context, itemIndex, 'semanticQueryInput');
+    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 });
+        }
+        setQueryParameter(parameter, value);
+    }
     return qs;
 }
 function queryPage(context, itemIndex, response) {
@@ -349,6 +472,24 @@ async function filterFieldOptions(context, types, encodeType = false) {
         });
     });
 }
+async function comparisonFieldOptions(context, types) {
+    var _a;
+    const selected = await optionModel(context);
+    if (!selected)
+        return [];
+    const allowed = new Set(types);
+    return ((_a = selected.model.query.comparisons) !== null && _a !== void 0 ? _a : [])
+        .filter((comparison) => allowed.has(comparison.valueType))
+        .map((comparison) => {
+        var _a;
+        const field = selected.model.fields.find((entry) => entry.key === comparison.field);
+        return {
+            name: ((_a = field === null || field === void 0 ? void 0 : field.title) === null || _a === void 0 ? void 0 : _a.trim()) || (0, lifespaceDiscovery_1.humanizeKey)(comparison.field),
+            value: `${comparison.valueType}:${comparison.field}`,
+            description: `${comparison.source} · ${comparison.valueType} · explicit LifeSpace comparison operators`,
+        };
+    });
+}
 async function relationFieldOptions(context, cardinality, filterableOnly = false) {
     const selected = await optionModel(context);
     if (!selected)
@@ -537,6 +678,16 @@ class LifeSpace {
                                 { displayName: 'Operator', name: 'operator', type: 'options', options: [{ name: 'Equals', value: 'exact' }, { name: 'From / Greater Than or Equal', value: 'from' }, { name: 'To / Less Than or Equal', value: 'to' }], default: 'exact' },
                                 { displayName: 'Value', name: 'value', type: 'dateTime', default: '', required: true },
                             ] },
+                        { displayName: 'Number Comparison', name: 'numberComparison', values: [
+                                { displayName: 'Field Name or ID', name: 'field', type: 'options', description: 'Fields and envelope values advertised by LifeSpace explicit comparison semantics. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.', typeOptions: { loadOptionsMethod: 'getNumericComparisonFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
+                                { displayName: 'Operator Name or ID', name: 'parameter', type: 'options', description: 'The option value is the exact query parameter published by LifeSpace; the adapter does not derive transport names. 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: 'number', default: 0, required: true },
+                            ] },
+                        { displayName: 'Date / Time Comparison', name: 'temporalComparison', values: [
+                                { displayName: 'Field Name or ID', name: 'field', type: 'options', description: 'Includes model date/datetime fields plus LifeSpace envelope timestamps such as createdAt/updatedAt when advertised. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.', typeOptions: { loadOptionsMethod: 'getTemporalComparisonFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
+                                { 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: '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 },
@@ -548,6 +699,45 @@ 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',
+                    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>.',
+                },
+                {
+                    displayName: 'Semantic Query Input', 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.',
+                        },
+                    },
+                    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.',
+                },
+                {
+                    displayName: 'Semantic 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>.',
+                },
                 {
                     displayName: 'Return All', name: 'returnAll', type: 'boolean', default: false,
                     displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
@@ -702,6 +892,64 @@ class LifeSpace {
                 async getBooleanFilterableFields() { return filterFieldOptions(this, ['boolean']); },
                 async getNumericFilterableFields() { return filterFieldOptions(this, ['integer', 'number']); },
                 async getTemporalFilterableFields() { return filterFieldOptions(this, ['date', 'datetime'], true); },
+                async getNumericComparisonFields() { return comparisonFieldOptions(this, ['integer', 'number']); },
+                async getTemporalComparisonFields() { return comparisonFieldOptions(this, ['date', 'datetime']); },
+                async getComparisonOperatorsForCurrentField() {
+                    var _a, _b;
+                    const selected = await optionModel(this);
+                    const { field } = comparisonFieldParts(this.getCurrentNodeParameter('&field'));
+                    const comparison = (_a = selected === null || selected === void 0 ? void 0 : selected.model.query.comparisons) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.field === field);
+                    return ((_b = comparison === null || comparison === void 0 ? void 0 : comparison.operators) !== null && _b !== void 0 ? _b : [])
+                        .filter((operator) => operator.transport === 'explicit')
+                        .map((operator) => {
+                        var _a;
+                        return ({
+                            name: (_a = COMPARISON_OPERATOR_LABELS[operator.operator]) !== null && _a !== void 0 ? _a : (0, lifespaceDiscovery_1.humanizeKey)(operator.operator),
+                            value: operator.parameter,
+                            description: `${operator.operator} · ${operator.transport} · ${operator.parameter}`,
+                        });
+                    });
+                },
+                async getLocalDateWindowFields() {
+                    var _a;
+                    const selected = await optionModel(this);
+                    if (!selected)
+                        return [];
+                    return ((_a = selected.model.query.comparisons) !== null && _a !== void 0 ? _a : [])
+                        .filter((comparison) => comparison.valueType === 'datetime' && comparison.localDateWindow)
+                        .map((comparison) => {
+                        var _a;
+                        const field = selected.model.fields.find((entry) => entry.key === comparison.field);
+                        return {
+                            name: ((_a = field === null || field === void 0 ? void 0 : field.title) === null || _a === void 0 ? void 0 : _a.trim()) || (0, lifespaceDiscovery_1.humanizeKey)(comparison.field),
+                            value: encodeLocalDateWindowSelector(comparison),
+                            description: `${comparison.source} · [start,end) local calendar window · Core resolves timezone/DST`,
+                        };
+                    });
+                },
+                async getCapabilityQueries() {
+                    var _a;
+                    const selected = await optionModel(this);
+                    return ((_a = selected === null || selected === void 0 ? void 0 : selected.model.query.capabilityQueries) !== null && _a !== void 0 ? _a : []).map((query) => ({
+                        name: `${(0, lifespaceDiscovery_1.humanizeKey)(query.capability)} · ${(0, lifespaceDiscovery_1.humanizeKey)(query.key)}`,
+                        value: query.key,
+                        description: `${query.semantics}${query.recurrenceExpansion === false ? ' · recurrence not expanded' : ''}`,
+                    }));
+                },
+                async getSemanticSorts() {
+                    var _a, _b, _c;
+                    const selected = await optionModel(this);
+                    const queryKey = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'semanticQueryKey');
+                    const query = (_a = selected === null || selected === void 0 ? void 0 : selected.model.query.capabilityQueries) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.key === queryKey);
+                    return ((_c = (_b = query === null || query === void 0 ? void 0 : query.ordering) === null || _b === void 0 ? void 0 : _b.values) !== null && _c !== void 0 ? _c : []).map((value) => {
+                        var _a, _b;
+                        return ({
+                            name: value === ((_a = query === null || query === void 0 ? void 0 : query.ordering) === null || _a === void 0 ? void 0 : _a.default) ? `${value} (Default)` : value,
+                            value,
+                            description: `${(_b = query === null || query === void 0 ? void 0 : query.key) !== null && _b !== void 0 ? _b : 'semantic query'} ordering`,
+                        });
+                    });
+                },
                 async getPersonFilterableFields() { return relationFieldOptions(this, undefined, true); },
                 async getEnumValuesForCurrentFilter() {
                     var _a, _b;
@@ -746,6 +994,13 @@ class LifeSpace {
                         ? { fields: action.input.fields.map((field) => mapperField(field, field.required === true)) }
                         : { fields: [] };
                 },
+                async getSemanticQueryInputFields() {
+                    var _a;
+                    const selected = await optionModel(this);
+                    const queryKey = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'semanticQueryKey');
+                    const query = (_a = selected === null || selected === void 0 ? void 0 : selected.model.query.capabilityQueries) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.key === queryKey);
+                    return query ? { fields: query.parameters.map(semanticQueryMapperField) } : { fields: [] };
+                },
             },
         };
     }