@ossy/platform 3.15.0 → 3.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "3.15.0",
+  "version": "3.16.0",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -48,15 +48,15 @@
     "@ossy/config": "^3.0.9",
     "@ossy/event-store": "^3.12.0",
     "@ossy/locale": "^3.4.0",
-    "@ossy/manifest": "^3.15.0",
+    "@ossy/manifest": "^3.16.0",
     "@ossy/observability": "^3.0.9",
     "@ossy/policies": "^3.0.9",
     "@ossy/router": "^3.0.9",
-    "@ossy/schema": "^3.15.0",
-    "@ossy/sdk": "^3.12.0",
+    "@ossy/schema": "^3.16.0",
+    "@ossy/sdk": "^3.16.0",
     "@ossy/tokens": "^3.11.1",
-    "@ossy/users": "^3.15.0",
-    "@ossy/workspaces": "^3.15.0",
+    "@ossy/users": "^3.16.0",
+    "@ossy/workspaces": "^3.16.0",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
@@ -77,5 +77,5 @@
     "Dockerfile",
     "docker-healthcheck.js"
   ],
-  "gitHead": "23517232ddc4f2c64ca0062faa3cad84ceaa34a7"
+  "gitHead": "1872fb1467bf656284aae35881c34960c3860807"
 }

package/src/audit/audit-helpers.js

@@ -19,14 +19,42 @@ export function hashPayload (payload) {
 /** Keep event payloads small — full task results stay outside the audit stream. */
 export function summarizeResult (result) {
   if (result == null) return null
-  if (typeof result !== 'object') {
-    return { kind: typeof result, preview: String(result).slice(0, 200) }
+  return previewValue(result, 0)
+}
+
+/**
+ * Resolved task inputs for the run detail. Empty maps are omitted.
+ *
+ * @param {unknown} inputs
+ * @returns {object | undefined}
+ */
+export function summarizeInputs (inputs) {
+  if (!inputs || typeof inputs !== 'object' || Array.isArray(inputs)) return undefined
+  if (!Object.keys(inputs).length) return undefined
+  const preview = previewValue(inputs, 0)
+  if (!preview || typeof preview !== 'object' || Array.isArray(preview)) return undefined
+  if (!Object.keys(preview).length) return undefined
+  return preview
+}
+
+function previewValue (value, depth) {
+  if (value == null || typeof value !== 'object') {
+    if (typeof value === 'string' && value.length > 240) return `${value.slice(0, 240)}…`
+    return value
+  }
+  if (depth >= 4) {
+    return Array.isArray(value)
+      ? { kind: 'array', length: value.length }
+      : { kind: 'object', keyCount: Object.keys(value).length }
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 12).map((item) => previewValue(item, depth + 1))
   }
-  if (Array.isArray(result)) {
-    return { kind: 'array', length: result.length }
+  const preview = {}
+  for (const key of Object.keys(value).slice(0, 24)) {
+    preview[key] = previewValue(value[key], depth + 1)
   }
-  const keys = Object.keys(result)
-  return { kind: 'object', keys: keys.slice(0, 20), keyCount: keys.length }
+  return preview
 }
 
 /** @param {Error | { message?: string, code?: string }} error */

package/src/audit/task-run-list.aggregate.js

@@ -42,6 +42,7 @@ export class TaskRunListProjection {
     if (event.event === 'Started') {
       entry.status = 'in progress'
       entry.startedAt = event.created
+      entry.triggeredBy = event.payload.triggeredBy ?? null
       runs.unshift(entry)
       return { workspaceId, runs: runs.slice(0, 200) }
     }
@@ -54,6 +55,7 @@ export class TaskRunListProjection {
         startedAt: event.created,
         completedAt: event.created,
         durationMs: event.payload.durationMs,
+        ...(event.payload.inputs ? { inputs: event.payload.inputs } : {}),
       })
       return { workspaceId, runs: runs.slice(0, 200) }
     }
@@ -66,6 +68,7 @@ export class TaskRunListProjection {
       durationMs: event.payload.durationMs,
       error: event.event === 'Failed' ? event.payload.error : undefined,
       resultSummary: event.event === 'Completed' ? event.payload.resultSummary : undefined,
+      ...(event.payload.inputs ? { inputs: event.payload.inputs } : {}),
     }
 
     return { workspaceId, runs }

package/src/audit/task-run-service.js

@@ -9,6 +9,7 @@ import {
   resolveActorId,
   resolveWorkspaceId,
   summarizeError,
+  summarizeInputs,
   summarizeResult,
 } from './audit-helpers.js'
 import { rejectOnAbort } from '../request-diagnostics.js'
@@ -105,6 +106,7 @@ export const TaskRunService = {
         actorId,
         durationMs,
         resultSummary: summarizeResult(result),
+        inputs: summarizeInputs(context.inputs),
       })
       recordTaskMetrics(taskId, durationMs)
       await MeteringService.record({
@@ -130,6 +132,7 @@ export const TaskRunService = {
         actorId,
         durationMs,
         error: summarizeError(error),
+        inputs: summarizeInputs(context.inputs),
       })
       recordTaskMetrics(taskId, durationMs)
       await MeteringService.record({
@@ -193,7 +196,7 @@ export const TaskRunService = {
     }
   },
 
-  async _appendCompleted ({ runId, taskId, workspaceId, actorId, durationMs, resultSummary }) {
+  async _appendCompleted ({ runId, taskId, workspaceId, actorId, durationMs, resultSummary, inputs }) {
     try {
       await Aggregate.Of(TaskRun, runId)
         .then(Aggregate.Add({
@@ -202,6 +205,7 @@ export const TaskRunService = {
           payload: {
             durationMs,
             resultSummary,
+            ...(inputs ? { inputs } : {}),
             ...taskRunScopePayload({ taskId, workspaceId }),
           },
         }))
@@ -210,7 +214,7 @@ export const TaskRunService = {
     }
   },
 
-  async _appendFailed ({ runId, taskId, workspaceId, actorId, durationMs, error }) {
+  async _appendFailed ({ runId, taskId, workspaceId, actorId, durationMs, error, inputs }) {
     try {
       await Aggregate.Of(TaskRun, runId)
         .then(Aggregate.Add({
@@ -219,6 +223,7 @@ export const TaskRunService = {
           payload: {
             durationMs,
             error,
+            ...(inputs ? { inputs } : {}),
             ...taskRunScopePayload({ taskId, workspaceId }),
           },
         }))

package/src/audit/task-run.aggregate.js

@@ -36,6 +36,7 @@ export class TaskRun {
             completedAt: event.created,
             durationMs: event.payload.durationMs,
             resultSummary: event.payload.resultSummary ?? null,
+            ...(event.payload.inputs ? { inputs: event.payload.inputs } : {}),
           }
 
         case 'Failed':
@@ -45,6 +46,7 @@ export class TaskRun {
             completedAt: event.created,
             durationMs: event.payload.durationMs,
             error: event.payload.error ?? null,
+            ...(event.payload.inputs ? { inputs: event.payload.inputs } : {}),
           }
 
         default:

package/src/file.schema.js

@@ -7,9 +7,5 @@ export default {
     { name: 'Key', type: 'text' },
     { name: 'ContentLength', type: 'number' },
     { name: 'ContentType', type: 'text' },
-    // Populated async by @ossy/media-tasks/tasks/resize-common-web
-    { name: 'blurhash', type: 'text' },
-    { name: 'width', type: 'number' },
-    { name: 'height', type: 'number' },
   ],
 }

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
 

package/src/tasks/task-service.spec.js

@@ -63,6 +63,73 @@ describe('TaskService triggers', () => {
     )).toBe(true)
   })
 
+  it('AND-narrows events with instance watch locations and MIME', () => {
+    const event = {
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+      resourceId: 'f1',
+      payload: {
+        belongsTo: 'ws1',
+        location: '/incoming/photos/a.jpg',
+        content: { ContentType: 'image/jpeg' },
+      },
+    }
+
+    expect(TaskService._matchesEventTrigger({
+      kind: 'on_event',
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+      location: { startsWith: '/incoming/' },
+      match: { 'content.ContentType': 'image/*' },
+    }, event)).toBe(true)
+
+    expect(TaskService._matchesEventTrigger({
+      kind: 'on_event',
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+      location: { startsWith: '/other/' },
+    }, event)).toBe(false)
+
+    expect(TaskService._matchesEventTrigger({
+      kind: 'on_event',
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+      match: { 'content.ContentType': 'video/*' },
+    }, event)).toBe(false)
+  })
+
+  it('treats configurable tasks without instance triggers as unarmed', async () => {
+    TaskService.setInstanceTriggersResolver(async () => [])
+    const result = await TaskService._eventTriggersForDispatch(
+      { id: 't1', configurable: true, triggers: [{ type: 'x', event: 'Created' }] },
+      'ws1',
+    )
+    expect(result.armed).toBe(false)
+    expect(result.triggers).toEqual([])
+    TaskService.setInstanceTriggersResolver(null)
+  })
+
+  it('uses instance triggers for configurable tasks', async () => {
+    const instanceTriggers = [{
+      kind: 'on_event',
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+      location: { startsWith: '/incoming/' },
+    }]
+    TaskService.setInstanceTriggersResolver(async () => instanceTriggers)
+    const result = await TaskService._eventTriggersForDispatch(
+      {
+        id: 't1',
+        configurable: true,
+        triggers: [{ type: '@ossy/platform/schema/file', event: 'Created' }],
+      },
+      'ws1',
+    )
+    expect(result.armed).toBe(true)
+    expect(result.triggers).toEqual(instanceTriggers)
+    TaskService.setInstanceTriggersResolver(null)
+  })
+
   it('skips primary derived task in on_action dispatch', () => {
     expect(isPrimaryTaskForAction('@ossy/booking/actions/create', '@ossy/booking/tasks/create')).toBe(true)
     expect(isPrimaryTaskForAction('@ossy/booking/actions/create', '@ossy/booking/tasks/send-reminder')).toBe(false)
@@ -120,6 +187,11 @@ describe('TaskRunList projection', () => {
         moduleId: 'media-tasks',
         trigger: 'on_event',
         belongsTo: 'ws1',
+        triggeredBy: {
+          resourceId: 'file1',
+          type: '@ossy/platform/schema/file',
+          event: 'Created',
+        },
       },
     }
 
@@ -127,6 +199,11 @@ describe('TaskRunList projection', () => {
     state = TaskRunListProjection.Apply(started, state)
     expect(state.runs).toHaveLength(1)
     expect(state.runs[0].status).toBe('in progress')
+    expect(state.runs[0].triggeredBy).toEqual({
+      resourceId: 'file1',
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+    })
 
     state = TaskRunListProjection.Apply({
       resourceId: 'run1',
@@ -145,6 +222,37 @@ describe('TaskRunList projection', () => {
     expect(state.runs[0].durationMs).toBe(1000)
   })
 
+  it('keeps resolved inputs on the listed run', () => {
+    let state = TaskRunListProjection.initialState('ws1')
+    state = TaskRunListProjection.Apply({
+      resourceId: 'run-inputs',
+      type: '@ossy/platform/schema/task-run',
+      event: 'Started',
+      created: 1000,
+      payload: {
+        taskId: '@ossy/media-tasks/tasks/visual-content-descriptors',
+        moduleId: 'media-tasks',
+        trigger: 'on_event',
+        belongsTo: 'ws1',
+      },
+    }, state)
+    state = TaskRunListProjection.Apply({
+      resourceId: 'run-inputs',
+      event: 'Completed',
+      created: 2000,
+      payload: {
+        durationMs: 40,
+        resultSummary: { title: 'A cat' },
+        inputs: { model: 'google/gemini-2.5-flash-lite' },
+        belongsTo: 'ws1',
+        taskId: '@ossy/media-tasks/tasks/visual-content-descriptors',
+        moduleId: 'media-tasks',
+      },
+    }, state)
+
+    expect(state.runs[0].inputs).toEqual({ model: 'google/gemini-2.5-flash-lite' })
+  })
+
   it('scopes Completed/Failed from payload.belongsTo (changestream dispatch)', () => {
     expect(TaskRunListProjection.scopeFromEvent({
       payload: { durationMs: 10 },