@open-mercato/scheduler 0.6.8-develop.7100.1.fbf66fca35 → 0.7.0

package/src/modules/scheduler/api/targets/route.ts

@@ -1,10 +1,10 @@
 import { NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { getModules } from '@open-mercato/shared/lib/modules/registry'
 import { commandRegistry } from '@open-mercato/shared/lib/commands/registry'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { listSchedulerSafeCommands } from '../../lib/scheduler-safe-commands'
-import { listSchedulerSafeQueueTargets } from '../../lib/safeQueueTargets'
 
 export const metadata = {
   requireAuth: true,
@@ -13,9 +13,7 @@ export const metadata = {
 
 /**
  * GET /api/scheduler/targets
- * Returns scheduler-safe queue names and command IDs for schedule target selection.
- * Only queues whose workers opted into scheduling (`schedulerSafe: true`) are
- * advertised; internal and system-only workers stay undiscoverable (#5213).
+ * Returns available queue names and command IDs for schedule target selection.
  */
 export async function GET(req: NextRequest) {
   const auth = await getAuthFromRequest(req)
@@ -23,8 +21,20 @@ export async function GET(req: NextRequest) {
     return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
   }
 
-  const queues = listSchedulerSafeQueueTargets()
-    .map((target) => ({ value: target.queue, label: target.queue }))
+  const modules = getModules()
+
+  const queueSet = new Set<string>()
+  for (const mod of modules) {
+    if (mod.workers) {
+      for (const worker of mod.workers) {
+        queueSet.add(worker.queue)
+      }
+    }
+  }
+
+  const queues = Array.from(queueSet)
+    .sort((a, b) => a.localeCompare(b))
+    .map((queue) => ({ value: queue, label: queue }))
 
   const commands = listSchedulerSafeCommands()
     .filter((command) => commandRegistry.has(command.commandId))
@@ -56,6 +66,7 @@ export const openApi: OpenApiRouteDoc = {
     GET: {
       operationId: 'listScheduleTargets',
       summary: 'List available queues and commands',
+      description: 'Returns all registered queue names (from module workers) and explicitly scheduler-safe command IDs that can be used as schedule targets.',
       responses: [
         {
           status: 200,

package/src/modules/scheduler/api/trigger/route.ts

@@ -7,7 +7,6 @@ import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { createQueue } from '@open-mercato/queue'
 import { getRedisUrlOrThrow } from '@open-mercato/shared/lib/redis/connection'
 import { ScheduledJob } from '../../data/entities.js'
-import { resolveScheduleAccess } from '../../lib/scheduleAccess.js'
 import { scheduleTriggerSchema } from '../../data/validators.js'
 import type { ExecuteSchedulePayload } from '../../workers/execute-schedule.worker.js'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
@@ -41,19 +40,30 @@ export async function POST(req: NextRequest) {
     const body = await req.json()
     const input = scheduleTriggerSchema.parse(body)
 
-    // Load by id alone, then apply isolation to the loaded row. Folding the actor's
-    // tenant/org into the lookup would make every system-scoped schedule unmatchable.
-    const schedule = await em.findOne(ScheduledJob, { id: input.id, deletedAt: null })
+    // Find the schedule with tenant/org scope filter
+    const findFilter: Record<string, unknown> = {
+      id: input.id,
+      deletedAt: null,
+    }
 
-    if (!schedule) {
-      return NextResponse.json({ error: translate('scheduler.error.not_found', 'Schedule not found') }, { status: 404 })
+    // Apply tenant isolation: scope the query to the user's tenant/org
+    if (auth.tenantId) {
+      findFilter.tenantId = auth.tenantId
+    }
+    if (auth.orgId) {
+      findFilter.organizationId = auth.orgId
     }
 
-    const access = resolveScheduleAccess(schedule, auth)
-    if (access === 'not_found') {
+    const schedule = await em.findOne(ScheduledJob, findFilter)
+
+    if (!schedule) {
       return NextResponse.json({ error: translate('scheduler.error.not_found', 'Schedule not found') }, { status: 404 })
     }
-    if (access === 'forbidden') {
+
+    // System-scoped schedules (no tenantId/orgId) require super-admin. Use the
+    // immutable `isSuperAdmin` flag — never compare mutable/spoofable role names.
+    const isSuperAdmin = auth.isSuperAdmin === true
+    if (!schedule.tenantId && !schedule.organizationId && !isSuperAdmin) {
       return NextResponse.json({ error: translate('scheduler.error.access_denied', 'Access denied') }, { status: 403 })
     }
 

package/src/modules/scheduler/backend/config/scheduled-jobs/page.tsx

@@ -39,7 +39,6 @@ type SchedulesResponse = {
   total?: number
   page?: number
   totalPages?: number
-  totalIsCapped?: boolean
 }
 
 function mapApiItem(item: Record<string, unknown>): ScheduleRow | null {
@@ -83,7 +82,6 @@ export default function SchedulerPage() {
   const [pageSize] = React.useState(20)
   const [total, setTotal] = React.useState(0)
   const [totalPages, setTotalPages] = React.useState(1)
-  const [totalIsCapped, setTotalIsCapped] = React.useState(false)
   const [search, setSearch] = React.useState('')
   const [isLoading, setIsLoading] = React.useState(false)
   const scopeVersion = useOrganizationScopeVersion()
@@ -106,7 +104,6 @@ export default function SchedulerPage() {
       setRows(mapped)
       setTotal(result?.total ?? 0)
       setTotalPages(result?.totalPages ?? 1)
-      setTotalIsCapped(result?.totalIsCapped === true)
     } catch (error) {
       flash(t('scheduler.error.fetch_failed', 'Failed to load schedules'), 'error')
       setRows([])
@@ -285,7 +282,7 @@ export default function SchedulerPage() {
               createLabel={t('scheduler.action.create', 'New Schedule')}
             />
           )}
-          pagination={{ page, pageSize, total, totalPages, totalIsCapped, onPageChange: setPage }}
+          pagination={{ page, pageSize, total, totalPages, onPageChange: setPage }}
           isLoading={isLoading}
           searchValue={search}
           onSearchChange={(value) => { setSearch(value); setPage(1) }}

package/src/modules/scheduler/cli.ts

@@ -3,7 +3,6 @@ import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import type { EntityManager } from '@mikro-orm/core'
 import { ScheduledJob } from './data/entities.js'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
-import { auditSchedulerModuleQueueRows } from './lib/safeQueueTargets'
 
 const writeLine = (text = '') => {
   process.stdout.write(`${text}\n`)
@@ -226,46 +225,4 @@ const startCommand: ModuleCli = {
   },
 }
 
-// Lists every persisted module-authored queue-target row with its current
-// dispatch verdict (#5213). Rows authored before the hardening by a
-// non-user-bound API key are indistinguishable from genuine registrations at
-// rest, so operators review the ALLOWED entries against their known integrations.
-const auditQueueTargetsCommand: ModuleCli = {
-  command: 'audit-queue-targets',
-  async run(rest) {
-    const args = parseArgs(rest)
-    const { resolve } = await createRequestContainer()
-    const em = resolve('em') as EntityManager
-
-    const where: Record<string, unknown> = { deletedAt: null, sourceType: 'module' }
-    if (args.tenant || args.tenantId) where.tenantId = args.tenant || args.tenantId
-
-    const rows = await em.find(ScheduledJob, where, {
-      orderBy: { name: 'ASC' },
-    })
-
-    const audits = auditSchedulerModuleQueueRows(rows)
-
-    writeLine(`Module-authored queue-target schedules: ${audits.length}`)
-    let allowedCount = 0
-    for (const audit of audits) {
-      const verdict = audit.dispatchAllowed ? 'ALLOWED' : 'blocked'
-      if (audit.dispatchAllowed) allowedCount += 1
-      writeLine(
-        `[${verdict}] ${audit.scheduleId}${audit.name ? ` — ${audit.name}` : ''}` +
-        ` module=${audit.sourceModule ?? '(none)'} queue=${audit.targetQueue ?? '(none)'}` +
-        ` enabled=${audit.isEnabled ? 'yes' : 'no'}`,
-      )
-    }
-
-    if (allowedCount > 0) {
-      writeLine('')
-      writeLine(`Review the ${allowedCount} ALLOWED row(s) above against your known module integrations.`)
-      writeLine('Pre-upgrade rows created with a non-user-bound API key cannot be distinguished')
-      writeLine('from genuine registrations at rest; disable anything unrecognized:')
-      writeLine('  yarn mercato scheduler list --tenant <tenantId>')
-    }
-  },
-}
-
-export default [listCommand, statusCommand, runCommand, startCommand, auditQueueTargetsCommand]
+export default [listCommand, statusCommand, runCommand, startCommand]

package/src/modules/scheduler/commands/jobs.ts

@@ -14,12 +14,7 @@ import type {
 } from '../data/validators.js'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import type { BullMQSchedulerService } from '../services/bullmqSchedulerService.js'
-import {
-  assertSchedulerQueueTargetAuthorized,
-  isSchedulerSafeQueue,
-  validateSchedulerTargetPayload,
-} from '../lib/safeQueueTargets.js'
-import type { SchedulerTargetRbacService } from '../lib/safeQueueTargets.js'
+
 /**
  * Snapshot of a schedule for undo/redo
  */
@@ -88,64 +83,6 @@ function toDate(value: Date | string | null | undefined): Date | null {
   return value instanceof Date ? value : new Date(value)
 }
 
-function canonicalJson(value: unknown): string {
-  if (value === null || typeof value !== 'object') return JSON.stringify(value ?? null)
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`
-  const entries = Object.entries(value as Record<string, unknown>)
-    .filter(([, v]) => v !== undefined)
-    .sort(([a], [b]) => a.localeCompare(b))
-  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(',')}}`
-}
-
-function normalizeTargetPayloadValue(value: unknown): unknown {
-  // `schedulerService.register()` persists `{}` as-is while the edit form sends
-  // `null` for an empty payload — treat the three empty shapes as equal (#5213).
-  if (value !== null && typeof value === 'object' && !Array.isArray(value)
-      && Object.keys(value as Record<string, unknown>).length === 0) return null
-  return value
-}
-
-function targetPayloadChanged(inputValue: unknown, storedValue: unknown): boolean {
-  return targetValueChanged(
-    normalizeTargetPayloadValue(inputValue),
-    normalizeTargetPayloadValue(storedValue),
-  )
-}
-
-function targetValueChanged(inputValue: unknown, storedValue: unknown): boolean {
-  if (inputValue === undefined) return false
-  return canonicalJson(inputValue ?? null) !== canonicalJson(storedValue ?? null)
-}
-
-type QueueTargetAuthorizationContext = CommandRuntimeContext
-
-async function assertQueueTargetAuthorizedForActor(
-  ctx: QueueTargetAuthorizationContext,
-  queue: string,
-): Promise<void> {
-  const rbacService = (() => {
-    try {
-      return ctx.container?.resolve<SchedulerTargetRbacService>('rbacService') ?? null
-    } catch {
-      return null
-    }
-  })()
-  const reason = await assertSchedulerQueueTargetAuthorized({
-    queue,
-    actorUserId: resolveCommandActorUserId(ctx),
-    tenantId: ctx.auth?.tenantId ?? null,
-    organizationId: ctx.auth?.orgId ?? null,
-    isSuperAdmin: ctx.auth?.isSuperAdmin === true,
-    rbacService,
-  })
-  if (reason) throw new CrudHttpError(403, { error: reason })
-}
-
-async function assertQueueTargetPayloadAllowed(queue: string, targetPayload: Record<string, unknown> | null | undefined): Promise<void> {
-  const reason = validateSchedulerTargetPayload(queue, targetPayload)
-  if (reason) throw new CrudHttpError(422, { error: `Invalid target payload for queue ${queue}: ${reason}` })
-}
-
 function resolveCommandActorUserId(ctx: CommandRuntimeContext): string | null {
   const auth = ctx.auth
   if (!auth) return null
@@ -275,11 +212,6 @@ const createScheduleCommand: CommandHandler<ScheduleCreateInput, { id: string }>
       throw new Error('Failed to calculate next run time')
     }
 
-    if (input.targetType === 'queue' && input.targetQueue) {
-      await assertQueueTargetAuthorizedForActor(ctx, input.targetQueue)
-      await assertQueueTargetPayloadAllowed(input.targetQueue, input.targetPayload)
-    }
-
     // Create schedule
     const schedule = em.create(ScheduledJob, {
       name: input.name,
@@ -296,8 +228,8 @@ const createScheduleCommand: CommandHandler<ScheduleCreateInput, { id: string }>
       targetPayload: input.targetPayload ?? null,
       requireFeature: input.requireFeature ?? null,
       isEnabled: input.isEnabled ?? true,
-      sourceType: 'user',
-      sourceModule: null,
+      sourceType: input.sourceType ?? 'user',
+      sourceModule: input.sourceModule ?? null,
       nextRunAt,
       createdByUserId: resolveCommandActorUserId(ctx),
       createdAt: new Date(),
@@ -378,76 +310,10 @@ const updateScheduleCommand: CommandHandler<ScheduleUpdateInput, { ok: boolean }
     if (schedule.organizationId) ensureOrganizationScope(ctx, schedule.organizationId)
     ensureCanManageSystemScopedJob(ctx, schedule)
 
-    // Module-authored schedules are trusted infrastructure wiring (#5213): their
-    // target and payload are owned by the registering module. Submitting them
-    // unchanged is a no-op (the edit form always resends every field) — only an
-    // actual change to provenance-relevant values is rejected.
-    const touchesModuleOwnedTarget =
-      schedule.sourceType === 'module'
-      && (
-        targetValueChanged(input.targetType, schedule.targetType)
-        || targetValueChanged(input.targetQueue, schedule.targetQueue)
-        || targetValueChanged(input.targetCommand, schedule.targetCommand)
-        || targetPayloadChanged(input.targetPayload, schedule.targetPayload)
-      )
-    if (touchesModuleOwnedTarget) {
-      const { translate } = await resolveTranslations()
-      throw new CrudHttpError(403, {
-        error: translate(
-          'scheduler.errors.module_target_immutable',
-          'Module-authored schedules own their target; only operational fields can be updated here.',
-        ),
-      })
-    }
-
     if (input.isEnabled === true && schedule.isEnabled !== true) {
       await enforceTenantActiveScheduleLimit(em, schedule.tenantId)
     }
 
-    const effectiveTargetType = input.targetType ?? schedule.targetType
-    const effectiveQueue = input.targetQueue ?? schedule.targetQueue
-    const queueChanged =
-      effectiveTargetType === 'queue'
-      && (
-        targetValueChanged(input.targetQueue, schedule.targetQueue)
-        || targetValueChanged(input.targetType, schedule.targetType)
-        || targetPayloadChanged(input.targetPayload, schedule.targetPayload)
-      )
-    if (effectiveTargetType === 'queue' && effectiveQueue) {
-      const retargetedToUnapprovedQueue =
-        input.targetQueue !== undefined
-        && input.targetQueue !== schedule.targetQueue
-        && !isSchedulerSafeQueue(input.targetQueue)
-      // A save that leaves a user-authored row ACTIVE on an unapproved queue
-      // restores the invariant the update schema used to enforce; disabling the
-      // row stays allowed so admins can remediate legacy targets from the UI.
-      // (Dispatch-time re-verification remains the backstop either way.)
-      const keepsUnapprovedQueueActive =
-        effectiveQueue != null
-        && !isSchedulerSafeQueue(effectiveQueue)
-        && input.isEnabled !== false
-        && schedule.isEnabled !== false
-      if (
-        (retargetedToUnapprovedQueue || keepsUnapprovedQueueActive)
-        && schedule.sourceType !== 'module'
-      ) {
-        const { translate } = await resolveTranslations()
-        throw new CrudHttpError(422, {
-          error: translate(
-            'scheduler.errors.queue_not_approved',
-            'Target queue is not an approved scheduler target. Only workers that opted into scheduling can be selected.',
-          ),
-        })
-      }
-      if (queueChanged) {
-        await assertQueueTargetAuthorizedForActor(ctx, effectiveQueue)
-        const effectivePayload = input.targetPayload !== undefined
-          ? input.targetPayload
-          : schedule.targetPayload
-        await assertQueueTargetPayloadAllowed(effectiveQueue, effectivePayload)
-      }
-    }
-
     const scheduleChanged = input.scheduleType !== undefined || input.scheduleValue !== undefined || input.timezone !== undefined
     const nextRunAt = scheduleChanged
       ? calculateNextRunForWrite(

package/src/modules/scheduler/data/__tests__/validators.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals'
+import { describe, it, expect, beforeAll } from '@jest/globals'
 import {
   scheduleCreateSchema,
   scheduleUpdateSchema,
@@ -13,7 +13,6 @@ import {
   clearSchedulerSafeCommandsForTests,
   registerSchedulerSafeCommands,
 } from '../../lib/scheduler-safe-commands'
-import { registerModules } from '@open-mercato/shared/lib/modules/registry'
 
 // Register test commands for validation tests
 const testCommand: CommandHandler<unknown, { ok: boolean }> = {
@@ -40,27 +39,6 @@ beforeAll(() => {
       requiredFeatures: ['scheduler.jobs.manage'],
     },
   ])
-  // Queue targets are only valid when their worker opted into scheduling
-  // (`schedulerSafe: true`). Seed one safe queue so schema tests can exercise
-  // queue-target validation (#5213).
-  registerModules([
-    {
-      id: 'test_module',
-      workers: [
-        {
-          id: 'test_module:workers:safe',
-          queue: 'test',
-          concurrency: 1,
-          schedulerSafe: true,
-          handler: async () => {},
-        },
-      ],
-    },
-  ] as never)
-})
-
-afterAll(() => {
-  ;(globalThis as Record<string, unknown>).__openMercatoModulesRegistry__ = null
 })
 
 const tenantId = '123e4567-e89b-12d3-a456-426614174000'
@@ -76,7 +54,7 @@ describe('scheduleCreateSchema', () => {
         scheduleValue: '0 0 * * *',
         timezone: 'UTC',
         targetType: 'queue',
-        targetQueue: 'test',
+        targetQueue: 'backup-queue',
         isEnabled: true,
       })
 
@@ -84,7 +62,7 @@ describe('scheduleCreateSchema', () => {
       expect(result.scopeType).toBe('system')
       expect(result.scheduleType).toBe('cron')
       expect(result.targetType).toBe('queue')
-      expect(result.targetQueue).toBe('test')
+      expect(result.targetQueue).toBe('backup-queue')
     })
 
     it('should accept valid organization-scoped interval schedule with command target', () => {
@@ -120,7 +98,7 @@ describe('scheduleCreateSchema', () => {
         scheduleType: 'interval',
         scheduleValue: '15m',
         targetType: 'queue',
-        targetQueue: 'test',
+        targetQueue: 'cleanup',
       })
 
       expect(result.scopeType).toBe('tenant')

package/src/modules/scheduler/data/validators.ts

@@ -4,7 +4,6 @@ import { validateInterval } from '../lib/intervalParser'
 import { commandRegistry } from '@open-mercato/shared/lib/commands/registry'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
 import { isSchedulerSafeCommandId } from '../lib/scheduler-safe-commands'
-import { isSchedulerSafeQueue, validateSchedulerTargetPayload } from '../lib/safeQueueTargets'
 
 /**
  * Validate that a command exists in the command registry
@@ -17,15 +16,6 @@ function validateCommandIsSchedulable(commandId: string): boolean {
   return isSchedulerSafeCommandId(commandId)
 }
 
-/**
- * Validate that a queue was declared scheduler-safe by its owning worker.
- * Internal and system-only workers (webhook processors, indexers, …) stay
- * undiscoverable as schedule targets — see issue #5213.
- */
-function validateSchedulerSafeQueue(queue: string | null | undefined): boolean {
-  return isSchedulerSafeQueue(queue)
-}
-
 /**
  * Base schedule fields
  */
@@ -49,6 +39,8 @@ const scheduleBaseSchema = z.object({
   requireFeature: z.string().optional().nullable(),
   
   isEnabled: z.boolean().default(true),
+  sourceType: z.enum(['user', 'module']).default('user'),
+  sourceModule: z.string().optional().nullable(),
 })
 
 /**
@@ -128,30 +120,6 @@ export const scheduleCreateSchema = scheduleBaseSchema
       path: ['targetCommand'],
     }
   )
-  .refine(
-    (data) => {
-      if (data.targetType === 'queue' && data.targetQueue) {
-        return validateSchedulerSafeQueue(data.targetQueue)
-      }
-      return true
-    },
-    {
-      message: 'Target queue is not an approved scheduler target. Only workers that opted into scheduling can be selected.',
-      path: ['targetQueue'],
-    }
-  )
-  .refine(
-    (data) => {
-      if (data.targetType === 'queue' && data.targetQueue) {
-        return validateSchedulerTargetPayload(data.targetQueue, data.targetPayload) === null
-      }
-      return true
-    },
-    {
-      message: 'Invalid target payload for the selected scheduler queue.',
-      path: ['targetPayload'],
-    }
-  )
 
 /**
  * Update schedule schema (all fields optional except id)
@@ -246,9 +214,6 @@ export const scheduleUpdateSchema = z.object({
       path: ['targetCommand'],
     }
   )
-  // Queue-target safety and payload-shape rules for updates are enforced in the
-  // scheduler.jobs.update command against the stored row, so unchanged targets
-  // (always resent by the edit form) and legacy remediation stays possible (#5213).
 
 /**
  * Delete schedule schema

package/src/modules/scheduler/i18n/de.json

@@ -48,8 +48,6 @@
   "scheduler.error.unauthorized": "Nicht autorisiert",
   "scheduler.error.update_failed": "Fehler beim Aktualisieren des Zeitplans",
   "scheduler.errors.id_required": "Zeitplankennung ist erforderlich.",
-  "scheduler.errors.module_target_immutable": "Von Modulen erstellte Zeitpläne besitzen ihr Ziel; nur operative Felder können hier geändert werden.",
-  "scheduler.errors.queue_not_approved": "Ziel-Queue ist kein genehmigtes Scheduler-Ziel. Nur Worker, die sich angemeldet haben, können ausgewählt werden.",
   "scheduler.execution.actions": "Aktionen",
   "scheduler.execution.completed_message": "Diese Ausführung wurde erfolgreich ohne Fehler abgeschlossen.",
   "scheduler.execution.details_title": "Ausführungsdetails",

package/src/modules/scheduler/i18n/en.json

@@ -48,8 +48,6 @@
   "scheduler.error.unauthorized": "Unauthorized",
   "scheduler.error.update_failed": "Failed to update schedule",
   "scheduler.errors.id_required": "Schedule identifier is required.",
-  "scheduler.errors.module_target_immutable": "Module-authored schedules own their target; only operational fields can be updated here.",
-  "scheduler.errors.queue_not_approved": "Target queue is not an approved scheduler target. Only workers that opted into scheduling can be selected.",
   "scheduler.execution.actions": "Actions",
   "scheduler.execution.completed_message": "This execution completed successfully without errors.",
   "scheduler.execution.details_title": "Execution Details",

package/src/modules/scheduler/i18n/es.json

@@ -48,8 +48,6 @@
   "scheduler.error.unauthorized": "No autorizado",
   "scheduler.error.update_failed": "Error al actualizar la programación",
   "scheduler.errors.id_required": "El identificador de programación es obligatorio.",
-  "scheduler.errors.module_target_immutable": "Los programados creados por módulos poseen su destino; solo los campos operativos pueden modificarse aquí.",
-  "scheduler.errors.queue_not_approved": "La cola de destino no es un destino aprobado del planificador. Solo se pueden seleccionar workers que hayan optado.",
   "scheduler.execution.actions": "Acciones",
   "scheduler.execution.completed_message": "Esta ejecución se completó con éxito sin errores.",
   "scheduler.execution.details_title": "Detalles de ejecución",

package/src/modules/scheduler/i18n/ko.json

@@ -48,8 +48,6 @@
   "scheduler.error.unauthorized": "권한이 없습니다",
   "scheduler.error.update_failed": "일정 수정에 실패했습니다",
   "scheduler.errors.id_required": "일정 식별자는 필수입니다.",
-  "scheduler.errors.module_target_immutable": "모듈이 생성한 일정은 대상을 소유하므로 여기서는 운영 필드만 수정할 수 있습니다.",
-  "scheduler.errors.queue_not_approved": "대상 큐는 승인된 스케줄러 대상이 아닙니다. 옵트인한 워커만 선택할 수 있습니다.",
   "scheduler.execution.actions": "작업",
   "scheduler.execution.completed_message": "이 실행은 오류 없이 성공적으로 완료되었습니다.",
   "scheduler.execution.details_title": "실행 상세 정보",

package/src/modules/scheduler/i18n/pl.json

@@ -48,8 +48,6 @@
   "scheduler.error.unauthorized": "Brak autoryzacji",
   "scheduler.error.update_failed": "Nie udało się zaktualizować harmonogramu",
   "scheduler.errors.id_required": "Identyfikator harmonogramu jest wymagany.",
-  "scheduler.errors.module_target_immutable": "Harmonogramy utworzone przez moduły są właścicielami swojego celu; tutaj można zmieniać wyłącznie pola operacyjne.",
-  "scheduler.errors.queue_not_approved": "Kolejka docelowa nie jest zatwierdzonym celem harmonogramu. Można wybrać tylko workery, które się zadeklarowały.",
   "scheduler.execution.actions": "Akcje",
   "scheduler.execution.completed_message": "To wykonanie zakończyło się pomyślnie bez błędów.",
   "scheduler.execution.details_title": "Szczegóły wykonania",