@ossy/platform 3.15.0 → 3.17.0

package/src/ssr/detect-mobile-device.spec.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from '@jest/globals'
+import { detectMobileDevice, parseSecChUaMobile } from './detect-mobile-device.js'
+
+describe('parseSecChUaMobile', () => {
+  it('returns true for the mobile client hint', () => {
+    expect(parseSecChUaMobile('?1')).toBe(true)
+  })
+
+  it('returns false for the desktop client hint', () => {
+    expect(parseSecChUaMobile('?0')).toBe(false)
+  })
+
+  it('returns null when the header is missing or malformed', () => {
+    expect(parseSecChUaMobile(undefined)).toBeNull()
+    expect(parseSecChUaMobile(null)).toBeNull()
+    expect(parseSecChUaMobile('')).toBeNull()
+    expect(parseSecChUaMobile('mobile')).toBeNull()
+  })
+
+  it('tolerates surrounding whitespace', () => {
+    expect(parseSecChUaMobile(' ?1 ')).toBe(true)
+  })
+})
+
+describe('detectMobileDevice', () => {
+  it('prefers the Sec-CH-UA-Mobile client hint when present', () => {
+    const req = { headers: { 'sec-ch-ua-mobile': '?1', 'user-agent': 'Mozilla/5.0 (Windows NT 10.0)' } }
+    expect(detectMobileDevice(req)).toBe(true)
+  })
+
+  it('falls back to sniffing User-Agent when the client hint is absent (e.g. Safari/Firefox)', () => {
+    const req = { headers: { 'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit' } }
+    expect(detectMobileDevice(req)).toBe(true)
+  })
+
+  it('treats desktop User-Agents as non-mobile when the client hint is absent', () => {
+    const req = { headers: { 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit' } }
+    expect(detectMobileDevice(req)).toBe(false)
+  })
+
+  it('supports Express-style req.get(...) as a fallback lookup', () => {
+    const req = { headers: {}, get: (name) => (name === 'Sec-CH-UA-Mobile' ? '?1' : undefined) }
+    expect(detectMobileDevice(req)).toBe(true)
+  })
+
+  it('defaults to false when no request or headers are available', () => {
+    expect(detectMobileDevice(undefined)).toBe(false)
+    expect(detectMobileDevice({})).toBe(false)
+  })
+})

package/src/storage/storage-keys.js

@@ -41,6 +41,30 @@ export function derivativeObjectKey (resourceId, variant) {
   return `${resourceId}:${variant}`
 }
 
+/**
+ * Task-scoped derivative key: `{resourceId}:task-{concept}-{artifactName}`.
+ *
+ * @param {string} resourceId
+ * @param {string} taskConcept
+ * @param {string} artifactName
+ * @returns {string}
+ */
+export function taskArtifactObjectKey (resourceId, taskConcept, artifactName) {
+  if (!taskConcept || typeof taskConcept !== 'string') {
+    throw new Error('[storage-keys] taskConcept is required')
+  }
+  if (!artifactName || typeof artifactName !== 'string') {
+    throw new Error('[storage-keys] artifactName is required')
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(taskConcept)) {
+    throw new Error('[storage-keys] invalid taskConcept')
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(artifactName)) {
+    throw new Error('[storage-keys] invalid artifactName')
+  }
+  return derivativeObjectKey(resourceId, `task-${taskConcept}-${artifactName}`)
+}
+
 export function assertStorageKey (key) {
   if (!key || typeof key !== 'string' || !KEY_PATTERN.test(key)) {
     throw new Error(`[storage-keys] invalid storage key: ${key}`)

package/src/storage/storage-keys.spec.js

@@ -1,5 +1,11 @@
 import { describe, expect, it } from '@jest/globals'
-import { originalObjectKey, derivativeObjectKey, assertStorageKey, coerceStorageKey } from './storage-keys.js'
+import {
+  originalObjectKey,
+  derivativeObjectKey,
+  taskArtifactObjectKey,
+  assertStorageKey,
+  coerceStorageKey,
+} from './storage-keys.js'
 
 describe('storage-keys', () => {
   it('originalObjectKey returns flat resourceId', () => {
@@ -10,6 +16,11 @@ describe('storage-keys', () => {
     expect(derivativeObjectKey('abc123', 'galleryMedium')).toBe('abc123:galleryMedium')
   })
 
+  it('taskArtifactObjectKey namespaces by task concept', () => {
+    expect(taskArtifactObjectKey('abc123', 'resize-common-web', 'galleryLarge'))
+      .toBe('abc123:task-resize-common-web-galleryLarge')
+  })
+
   it('rejects path-like keys', () => {
     expect(() => assertStorageKey('media/ws/file')).toThrow()
   })

package/src/tasks/in-process-sdk.js

@@ -1,21 +1,6 @@
 import { resolveActionId } from '@ossy/sdk'
 import { ActionService } from '../actions/action.service.js'
 import { IntegrationService } from '../integration.service.js'
-import { StorageClient } from '../storage/storage.client.js'
-import { derivativeObjectKey } from '../storage/storage-keys.js'
-
-/**
- * @param {unknown} file
- * @returns {Promise<Buffer>}
- */
-async function fileToBuffer (file) {
-  if (Buffer.isBuffer(file)) return file
-  if (file instanceof Uint8Array) return Buffer.from(file)
-  if (typeof file?.arrayBuffer === 'function') {
-    return Buffer.from(await file.arrayBuffer())
-  }
-  throw new Error('[InProcessSdk] uploadNamedVersion expects a File, Blob, Buffer, or Uint8Array')
-}
 
 /**
  * Resolve actor/workspace from an eventstore document for nested action invokes.
@@ -39,8 +24,7 @@ function reqFromEvent (event) {
  * Same-process SDK for changestream / scheduled tasks when no HTTP bot
  * credentials (`API_URL` + `OSSY_API_KEY`) are configured.
  *
- * Implements the surface media and follow-up tasks use: `invoke` and
- * `resources.uploadNamedVersion`, via ActionService + StorageClient.
+ * Implements `invoke` via ActionService (task outputs write through patch-content).
  *
  * @param {{ req?: { userId?: string, workspaceId?: string } }} [options]
  */
@@ -69,38 +53,6 @@ export function createInProcessSdk (options = {}) {
     withEventContext (event) {
       return createInProcessSdk({ req: reqFromEvent(event) })
     },
-
-    get resources () {
-      return {
-        /**
-         * Patch named derivative metadata, then write bytes to storage.
-         * @param {{ id: string, name: string, file: File | Blob | Buffer | Uint8Array }} args
-         */
-        async uploadNamedVersion ({ id, name, file }) {
-          if (!id) throw new Error('[InProcessSdk] uploadNamedVersion requires id')
-          if (!name) throw new Error('[InProcessSdk] uploadNamedVersion requires name')
-          if (!file) throw new Error('[InProcessSdk] uploadNamedVersion requires file')
-
-          const size = typeof file.size === 'number' ? file.size : undefined
-          const type = typeof file.type === 'string' ? file.type : undefined
-          const buffer = await fileToBuffer(file)
-
-          const resource = await sdk.invoke('@ossy/resources/actions/upload-named-version', {
-            id,
-            namedVersion: name,
-            // HTTP SDK historically sent `name`; accept either in the task.
-            name,
-            size: size ?? buffer.length,
-            type,
-          })
-
-          // Action response may rewrite `sizes` to read URLs via withResourceMedia;
-          // always persist with the canonical derivative key.
-          await StorageClient.save(derivativeObjectKey(id, name), buffer)
-          return resource
-        },
-      }
-    },
   }
 
   return sdk

package/src/tasks/in-process-sdk.spec.js

@@ -1,15 +1,9 @@
 import { describe, expect, it, jest } from '@jest/globals'
 
 const invokeMock = jest.fn(async (_id, context) => ({
-  id: context.payload.id,
-  content: {
-    sizes: { [context.payload.namedVersion]: `${context.payload.id}:${context.payload.namedVersion}` },
-    uploadUrl: '/local-storage?key=unused',
-  },
+  id: context.payload.resourceId ?? context.payload.id,
 }))
 
-const saveMock = jest.fn(async () => {})
-
 jest.unstable_mockModule('../actions/action.service.js', () => ({
   ActionService: { invoke: invokeMock },
 }))
@@ -18,10 +12,6 @@ jest.unstable_mockModule('../integration.service.js', () => ({
   IntegrationService: { get: () => null },
 }))
 
-jest.unstable_mockModule('../storage/storage.client.js', () => ({
-  StorageClient: { save: saveMock },
-}))
-
 const { createInProcessSdk } = await import('./in-process-sdk.js')
 
 describe('createInProcessSdk', () => {
@@ -58,32 +48,4 @@ describe('createInProcessSdk', () => {
       }),
     )
   })
-
-  it('uploadNamedVersion patches then saves bytes', async () => {
-    invokeMock.mockClear()
-    saveMock.mockClear()
-    const sdk = createInProcessSdk()
-    const bytes = new Uint8Array([1, 2, 3, 4])
-
-    await sdk.resources.uploadNamedVersion({
-      id: 'file1',
-      name: 'thumbnailSmall',
-      file: new File([bytes], 'thumbnailSmall', { type: 'image/jpeg' }),
-    })
-
-    expect(invokeMock).toHaveBeenCalledWith(
-      '@ossy/resources/actions/upload-named-version',
-      expect.objectContaining({
-        payload: expect.objectContaining({
-          id: 'file1',
-          namedVersion: 'thumbnailSmall',
-          type: 'image/jpeg',
-        }),
-      }),
-    )
-    expect(saveMock).toHaveBeenCalledWith(
-      'file1:thumbnailSmall',
-      expect.any(Buffer),
-    )
-  })
 })

package/src/tasks/task-service.js

@@ -2,7 +2,7 @@ import { matchesGlob } from './glob.js'
 import { matchesCron } from './cron.js'
 import { IntegrationService } from '../integration.service.js'
 import { createLogger } from '@ossy/observability'
-import { isPrimaryTaskForAction, taskIdFromActionId } from '@ossy/schema'
+import { isPrimaryTaskForAction, resolveTaskInputs, taskIdFromActionId } from '@ossy/schema'
 import { TaskRunService } from '../audit/task-run-service.js'
 import { resolveClientIp, runWithEventContext } from '@ossy/event-store'
 
@@ -38,6 +38,27 @@ export class TaskService {
    */
   static _sdk = null
 
+  /**
+   * Optional workspace triggers for configurable tasks.
+   * Return `null` when no instance exists; return `[]` when inactive;
+   * return trigger objects (definition shape) to OR-match instead of definition triggers.
+   * @type {null | ((args: { taskId: string, workspaceId?: string | null }) => Promise<object[] | null>)}
+   */
+  static _instanceTriggersResolver = null
+
+  /**
+   * Optional per-workspace schedules derived from instance on_schedule triggers.
+   * Only consulted for configurable tasks.
+   * @type {null | ((args: { taskId: string }) => Promise<Array<{ workspaceId: string, schedule: string }>>)}
+   */
+  static _instanceScheduleResolver = null
+
+  /**
+   * Optional per-workspace input config for configurable tasks.
+   * @type {null | ((args: { taskId: string, workspaceId?: string | null }) => Promise<object>)}
+   */
+  static _instanceConfigResolver = null
+
   /**
    * Register the SDK instance that every task will receive as `sdk`.
    * Call this once during application startup before ChangeStream / scheduler begin.
@@ -47,6 +68,140 @@ export class TaskService {
     TaskService._sdk = sdk
   }
 
+  /**
+   * @param {null | ((args: { taskId: string, workspaceId?: string | null }) => Promise<object[] | null>)} resolver
+   */
+  static setInstanceTriggersResolver (resolver) {
+    TaskService._instanceTriggersResolver = typeof resolver === 'function' ? resolver : null
+  }
+
+  /**
+   * @param {null | ((args: { taskId: string }) => Promise<Array<{ workspaceId: string, schedule: string }>>)} resolver
+   */
+  static setInstanceScheduleResolver (resolver) {
+    TaskService._instanceScheduleResolver = typeof resolver === 'function' ? resolver : null
+  }
+
+  /**
+   * @param {null | ((args: { taskId: string, workspaceId?: string | null }) => Promise<object>)} resolver
+   */
+  static setInstanceConfigResolver (resolver) {
+    TaskService._instanceConfigResolver = typeof resolver === 'function' ? resolver : null
+  }
+
+  /**
+   * Load instance config and resolve declared inputs onto the run context.
+   *
+   * @param {object} metadata
+   * @param {object} context
+   * @returns {Promise<Record<string, unknown>>}
+   */
+  static async _resolveTaskInputs (metadata, context) {
+    const workspaceId = context?.req?.workspaceId
+      ?? context?.payload?.workspaceId
+      ?? context?.payload?.belongsTo
+      ?? context?.event?.belongsTo
+      ?? context?.event?.payload?.belongsTo
+      ?? null
+    let config = {}
+    if (TaskService._instanceConfigResolver && metadata?.id && workspaceId) {
+      try {
+        const loaded = await TaskService._instanceConfigResolver({
+          taskId: metadata.id,
+          workspaceId,
+        })
+        if (loaded && typeof loaded === 'object' && !Array.isArray(loaded)) config = loaded
+      } catch (err) {
+        _serviceLog.warn(
+          `Instance config resolver failed for ${metadata.id}: ${err?.message || err}`,
+        )
+      }
+    }
+    return resolveTaskInputs(metadata?.inputs, {
+      payload: context?.payload,
+      config,
+      triggerConfig: context?.triggerConfig,
+      event: context?.event,
+      resource: context?.resource,
+    })
+  }
+
+  /**
+   * @param {object} metadata
+   * @param {function} handler
+   * @returns {function}
+   */
+  static _handlerWithInputs (metadata, handler) {
+    return async (context) => {
+      context.inputs = await TaskService._resolveTaskInputs(metadata, context)
+      return handler(context)
+    }
+  }
+
+  /**
+   * @param {object | null | undefined} metadata
+   * @returns {boolean}
+   */
+  static _isConfigurable (metadata) {
+    if (metadata?.configurable === true) return true
+    // Legacy metadata still carrying instanceConfig
+    if (metadata?.instanceConfig && typeof metadata.instanceConfig === 'object') return true
+    return false
+  }
+
+  /**
+   * @param {object} metadata
+   * @param {string | null | undefined} workspaceId
+   * @returns {Promise<object[] | null>}
+   */
+  static async _resolveInstanceTriggers (metadata, workspaceId) {
+    if (!TaskService._instanceTriggersResolver || !metadata?.id || !workspaceId) {
+      return null
+    }
+    try {
+      const triggers = await TaskService._instanceTriggersResolver({
+        taskId: metadata.id,
+        workspaceId,
+      })
+      if (triggers == null) return null
+      return Array.isArray(triggers) ? triggers : []
+    } catch (err) {
+      _serviceLog.warn(
+        `Instance triggers resolver failed for ${metadata.id}: ${err?.message || err}`,
+      )
+      return null
+    }
+  }
+
+  /**
+   * Event triggers used for dispatch: instance OR-list when configurable, else definition.
+   *
+   * @param {object} metadata
+   * @param {string | null | undefined} workspaceId
+   * @returns {Promise<{ triggers: object[], armed: boolean }>}
+   */
+  static async _eventTriggersForDispatch (metadata, workspaceId) {
+    if (!TaskService._isConfigurable(metadata)) {
+      return {
+        triggers: Array.isArray(metadata?.triggers) ? metadata.triggers : [],
+        armed: true,
+      }
+    }
+
+    const instanceTriggers = await TaskService._resolveInstanceTriggers(metadata, workspaceId)
+    if (!instanceTriggers || instanceTriggers.length === 0) {
+      return { triggers: [], armed: false }
+    }
+
+    return {
+      triggers: instanceTriggers.filter((trigger) => {
+        const kind = trigger?.trigger ?? trigger?.on ?? trigger?.kind
+        return kind !== 'on_action' && kind !== 'on_schedule'
+      }),
+      armed: true,
+    }
+  }
+
   /**
    * Register a task module to be dispatched on matching events
    * and/or on a cron schedule.
@@ -112,7 +267,7 @@ export class TaskService {
     return runWithEventContext({ ip: resolveClientIp(context.req) }, () =>
       TaskRunService.execute({
         taskId: id,
-        handler: task.handler,
+        handler: TaskService._handlerWithInputs(task.metadata, task.handler),
         context: invokeContext,
         trigger: 'invoke',
         triggeredBy: {
@@ -146,8 +301,9 @@ export class TaskService {
    * Dispatches a single event (fullDocument from the changestream) to all
    * registered tasks whose triggers match.
    * @param {object} event - The eventstore fullDocument.
+   * @returns {Promise<void>}
    */
-  static dispatch(event, { sdk } = {}) {
+  static async dispatch(event, { sdk } = {}) {
     if (!event) return
 
     const baseSdk = sdk ?? TaskService._sdk
@@ -155,11 +311,14 @@ export class TaskService {
       ? baseSdk.withEventContext(event)
       : baseSdk
 
+    const workspaceId = event.payload?.belongsTo ?? event.belongsTo ?? null
+
     for (const { metadata, handler } of TaskService._tasks) {
-      const triggers = metadata.triggers ?? []
-      const matched = triggers.some(trigger => TaskService._matchesEventTrigger(trigger, event))
+      const { triggers, armed } = await TaskService._eventTriggersForDispatch(metadata, workspaceId)
+      if (!armed) continue
 
-      if (!matched) continue
+      const matchedTrigger = triggers.find((trigger) => TaskService._matchesEventTrigger(trigger, event))
+      if (!matchedTrigger) continue
 
       _serviceLog.info(`Dispatching task "${metadata.id}"`)
 
@@ -167,14 +326,15 @@ export class TaskService {
         { sdk: effectiveSdk, integrations: IntegrationService, log: createLogger(metadata.id) },
         {
           event,
-          payload: { workspaceId: event.payload?.belongsTo },
+          payload: { workspaceId },
+          triggerConfig: matchedTrigger.config,
         },
       )
 
       const _taskId = metadata.id
       TaskRunService.executeAsync({
         taskId: _taskId,
-        handler,
+        handler: TaskService._handlerWithInputs(metadata, handler),
         context: taskContext,
         trigger: 'on_event',
         triggeredBy: {
@@ -202,8 +362,9 @@ export class TaskService {
    *   req?: import('express').Request,
    *   sdk?: unknown,
    * }} actionContext
+   * @returns {Promise<void>}
    */
-  static dispatchOnAction (actionContext) {
+  static async dispatchOnAction (actionContext) {
     const {
       actionId,
       actionInvocationId,
@@ -215,13 +376,18 @@ export class TaskService {
       sdk,
     } = actionContext
 
+    const workspaceId = req?.workspaceId
+      ?? payload?.workspaceId
+      ?? payload?.belongsTo
+      ?? null
+
     for (const { metadata, handler } of TaskService._tasks) {
       if (isPrimaryTaskForAction(actionId, metadata.id)) continue
 
-      const triggers = metadata.triggers ?? []
-      const matched = triggers.some(trigger => TaskService._matchesActionTrigger(trigger, actionId))
+      const triggers = Array.isArray(metadata?.triggers) ? metadata.triggers : []
+      const matchedTrigger = triggers.find((trigger) => TaskService._matchesActionTrigger(trigger, actionId))
 
-      if (!matched) continue
+      if (!matchedTrigger) continue
 
       _serviceLog.info(`Dispatching on_action task "${metadata.id}" for action "${actionId}"`)
 
@@ -233,6 +399,7 @@ export class TaskService {
           req,
           actionInvocationId,
           payload,
+          triggerConfig: matchedTrigger.config,
         },
         {
           action: {
@@ -247,7 +414,7 @@ export class TaskService {
       const _taskId = metadata.id
       TaskRunService.executeAsync({
         taskId: _taskId,
-        handler,
+        handler: TaskService._handlerWithInputs(metadata, handler),
         context: taskContext,
         trigger: 'on_action',
         triggeredBy: {
@@ -261,16 +428,61 @@ export class TaskService {
     }
   }
 
+  /**
+   * Collect cron jobs for a task.
+   * System tasks: definition schedule only.
+   * Configurable tasks: instance on_schedule triggers only (inactive when none).
+   *
+   * @param {object} metadata
+   * @returns {Promise<Array<{ workspaceId: string | null, schedule: string }>>}
+   */
+  static async _scheduledJobsFor (metadata) {
+    /** @type {Array<{ workspaceId: string | null, schedule: string }>} */
+    const jobs = []
+
+    if (TaskService._isConfigurable(metadata)) {
+      if (TaskService._instanceScheduleResolver && metadata?.id) {
+        try {
+          const fromInstances = await TaskService._instanceScheduleResolver({ taskId: metadata.id })
+          for (const job of fromInstances || []) {
+            if (!job?.workspaceId || typeof job.schedule !== 'string' || !job.schedule.trim()) continue
+            jobs.push({
+              workspaceId: job.workspaceId,
+              schedule: job.schedule.trim(),
+              ...(job.config ? { config: job.config } : {}),
+            })
+          }
+        } catch (err) {
+          _serviceLog.warn(
+            `Instance schedule resolver failed for ${metadata.id}: ${err?.message || err}`,
+          )
+        }
+      }
+      return jobs
+    }
+
+    if (typeof metadata?.schedule === 'string' && metadata.schedule.trim()) {
+      jobs.push({ workspaceId: null, schedule: metadata.schedule.trim() })
+    }
+    for (const trigger of metadata?.triggers ?? []) {
+      const kind = trigger?.trigger ?? trigger?.on ?? trigger?.kind
+      const schedule = typeof trigger?.schedule === 'string' ? trigger.schedule.trim() : ''
+      if ((kind === 'on_schedule' || (!kind && schedule)) && schedule) {
+        jobs.push({ workspaceId: null, schedule })
+      }
+    }
+    return jobs
+  }
+
   /**
    * Starts a 60-second interval that fires each scheduled task whose cron
    * expression matches the current minute.  Calls the handler directly
    * (no synthetic MongoDB events).
    */
   static startScheduler() {
-    const scheduledTasks = TaskService._tasks.filter(t => !!t.metadata.schedule)
-    if (scheduledTasks.length === 0) return
+    if (TaskService._tasks.length === 0) return
 
-    _serviceLog.info(`Scheduler started for ${scheduledTasks.length} task(s)`)
+    _serviceLog.info(`Scheduler started for ${TaskService._tasks.length} registered task(s)`)
 
     TaskService._stopped = false
     TaskService._schedulerInterval = setInterval(() => {
@@ -278,27 +490,44 @@ export class TaskService {
 
       const now = new Date()
 
-      for (const { metadata, handler } of scheduledTasks) {
-        if (!matchesCron(metadata.schedule, now)) continue
-
-        _serviceLog.info(`Schedule fired for task "${metadata.id}"`)
-
-        const taskContext = {
-          event: { type: 'scheduled', taskId: metadata.id },
-          sdk: TaskService._sdk,
-          integrations: IntegrationService,
-          log: createLogger(metadata.id),
-        }
-
-        const _taskId = metadata.id
-        TaskRunService.executeAsync({
-          taskId: _taskId,
-          handler,
-          context: taskContext,
-          trigger: 'on_schedule',
-          triggeredBy: { schedule: metadata.schedule },
-          executionEnv: 'ossy_server',
-          audit: metadata.audit !== false,
+      for (const { metadata, handler } of TaskService._tasks) {
+        TaskService._scheduledJobsFor(metadata).then((jobs) => {
+          if (TaskService._stopped) return
+          for (const job of jobs) {
+            if (!matchesCron(job.schedule, now)) continue
+
+            _serviceLog.info(
+              `Schedule fired for task "${metadata.id}"`
+              + (job.workspaceId ? ` (workspace ${job.workspaceId})` : ''),
+            )
+
+            const taskContext = {
+              event: { type: 'scheduled', taskId: metadata.id },
+              sdk: TaskService._sdk,
+              integrations: IntegrationService,
+              log: createLogger(metadata.id),
+              payload: job.workspaceId ? { workspaceId: job.workspaceId } : undefined,
+              req: job.workspaceId ? { workspaceId: job.workspaceId, userId: 'system' } : undefined,
+              triggerConfig: job.config,
+            }
+
+            TaskRunService.executeAsync({
+              taskId: metadata.id,
+              handler: TaskService._handlerWithInputs(metadata, handler),
+              context: taskContext,
+              trigger: 'on_schedule',
+              triggeredBy: {
+                schedule: job.schedule,
+                ...(job.workspaceId ? { workspaceId: job.workspaceId } : {}),
+              },
+              executionEnv: 'ossy_server',
+              audit: metadata.audit !== false,
+            })
+          }
+        }).catch((err) => {
+          _serviceLog.warn(
+            `Scheduler tick failed for ${metadata.id}: ${err?.message || err}`,
+          )
         })
       }
     }, SCHEDULER_INTERVAL_MS)
@@ -322,7 +551,7 @@ export class TaskService {
    * @param {string} actionId
    */
   static _matchesActionTrigger (trigger, actionId) {
-    const kind = trigger.trigger ?? trigger.on
+    const kind = trigger.trigger ?? trigger.on ?? trigger.kind
     if (kind !== 'on_action') return false
 
     const pattern = trigger.action
@@ -335,11 +564,11 @@ export class TaskService {
    * Returns true when an event trigger descriptor matches the given eventstore document.
    *
    * ADR 0008: `trigger.type` = schemaId, `trigger.event` = lifecycle/custom name.
-   * Skips `on_action` triggers (handled by {@link TaskService.dispatchOnAction}).
+   * Skips `on_action` / `on_schedule` triggers (handled elsewhere).
    */
   static _matchesEventTrigger (trigger, event) {
-    const kind = trigger.trigger ?? trigger.on
-    if (kind === 'on_action') return false
+    const kind = trigger.trigger ?? trigger.on ?? trigger.kind
+    if (kind === 'on_action' || kind === 'on_schedule') return false
 
     if (trigger.excludeTypes?.includes(event.type)) return false