@minionry/minion 0.7.36

package/dist/server/services/schedule/agent-schedule-store.js

@@ -0,0 +1,232 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { writeFileAtomic } from '../../utils/file-store.js';
+import { spacePath } from '../space-layout.js';
+import { isEngineId } from '../websocket/types.js';
+import { computeNextFireAt, MAX_SCHEDULE_HISTORY, SCHEDULE_MIN_INTERVAL_MS, } from './schedule-store.js';
+export { computeNextFireAt, MAX_SCHEDULE_HISTORY, SCHEDULE_MIN_INTERVAL_MS };
+export function isAgentScheduleTiming(timing) {
+    return timing.kind === 'once' || timing.kind === 'interval';
+}
+export function agentScheduleStorePath(workingDir) {
+    return spacePath(workingDir, 'agents', 'schedules.json');
+}
+function generateAgentScheduleId() {
+    return `agsched-${randomUUID().replace(/-/g, '').slice(0, 8)}`;
+}
+function clampTiming(timing) {
+    if (timing.kind === 'interval') {
+        return { kind: 'interval', everyMs: Math.max(timing.everyMs, SCHEDULE_MIN_INTERVAL_MS) };
+    }
+    return timing;
+}
+function isScheduleFireStatus(value) {
+    return (value === 'started' ||
+        value === 'completed' ||
+        value === 'failed' ||
+        value === 'skipped-overlap' ||
+        value === 'missed');
+}
+function normalizeTiming(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const t = raw;
+    if (t.kind === 'once') {
+        if (typeof t.at !== 'string' || Number.isNaN(new Date(t.at).getTime()))
+            return null;
+        return { kind: 'once', at: t.at };
+    }
+    if (t.kind === 'interval') {
+        if (typeof t.everyMs !== 'number' || !Number.isFinite(t.everyMs))
+            return null;
+        return clampTiming({ kind: 'interval', everyMs: t.everyMs });
+    }
+    return null;
+}
+function normalizeEngineOverride(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const o = raw;
+    if (!isEngineId(o.engine))
+        return undefined;
+    if (typeof o.model !== 'string' || !o.model)
+        return undefined;
+    if (typeof o.effortLevel !== 'string' || !o.effortLevel)
+        return undefined;
+    return {
+        engine: o.engine,
+        model: o.model,
+        effortLevel: o.effortLevel,
+        ...(typeof o.fastMode === 'boolean' ? { fastMode: o.fastMode } : {}),
+        ...(typeof o.ultracode === 'boolean' ? { ultracode: o.ultracode } : {}),
+        ...(typeof o.systemPromptProfile === 'string' && o.systemPromptProfile
+            ? { systemPromptProfile: o.systemPromptProfile }
+            : {}),
+        ...(typeof o.systemPromptLang === 'string' && o.systemPromptLang
+            ? { systemPromptLang: o.systemPromptLang }
+            : {}),
+    };
+}
+function normalizeHistoryEntry(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const e = raw;
+    if (typeof e.at !== 'string')
+        return null;
+    if (!isScheduleFireStatus(e.status))
+        return null;
+    if (typeof e.tabId !== 'string' && e.tabId !== null)
+        return null;
+    const entry = { at: e.at, status: e.status, tabId: e.tabId };
+    if (typeof e.error === 'string')
+        entry.error = e.error;
+    return entry;
+}
+function normalizeLastFire(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const l = raw;
+    if (typeof l.at !== 'string')
+        return undefined;
+    if (!isScheduleFireStatus(l.status))
+        return undefined;
+    if (typeof l.tabId !== 'string' && l.tabId !== null)
+        return undefined;
+    return { at: l.at, status: l.status, tabId: l.tabId };
+}
+function normalizeAgentScheduleRecord(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    if (typeof r.id !== 'string' || !r.id)
+        return null;
+    if (typeof r.prompt !== 'string' || !r.prompt)
+        return null;
+    const timing = normalizeTiming(r.timing);
+    if (!timing)
+        return null;
+    const history = Array.isArray(r.history)
+        ? r.history.map(normalizeHistoryEntry).filter((e) => e !== null)
+        : [];
+    return {
+        ...r,
+        id: r.id,
+        createdAt: typeof r.createdAt === 'string' ? r.createdAt : new Date().toISOString(),
+        name: typeof r.name === 'string' ? r.name : undefined,
+        prompt: r.prompt,
+        engineOverride: normalizeEngineOverride(r.engineOverride),
+        timing,
+        enabled: typeof r.enabled === 'boolean' ? r.enabled : true,
+        nextFireAt: typeof r.nextFireAt === 'string' ? r.nextFireAt : null,
+        lastFire: normalizeLastFire(r.lastFire),
+        history,
+    };
+}
+export class AgentScheduleStore {
+    schedulesPath;
+    data;
+    constructor(workingDir) {
+        this.schedulesPath = agentScheduleStorePath(workingDir);
+        this.data = this.load();
+    }
+    load() {
+        try {
+            if (existsSync(this.schedulesPath)) {
+                const raw = JSON.parse(readFileSync(this.schedulesPath, 'utf-8'));
+                const rawSchedules = Array.isArray(raw?.schedules) ? raw.schedules : [];
+                const schedules = rawSchedules
+                    .map((s) => normalizeAgentScheduleRecord(s))
+                    .filter((s) => s !== null);
+                return { version: 1, schedules };
+            }
+        }
+        catch (error) {
+            console.error('[AgentScheduleStore] Error loading schedules:', error);
+        }
+        return { version: 1, schedules: [] };
+    }
+    save() {
+        try {
+            writeFileAtomic(this.schedulesPath, JSON.stringify(this.data, null, 2));
+        }
+        catch (error) {
+            console.error('[AgentScheduleStore] Error saving schedules:', error);
+        }
+    }
+    list() {
+        return this.data.schedules.map((s) => ({ ...s }));
+    }
+    get(id) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        return record ? { ...record } : undefined;
+    }
+    create(fields) {
+        const now = new Date();
+        const timing = clampTiming(fields.timing);
+        const record = {
+            id: generateAgentScheduleId(),
+            createdAt: now.toISOString(),
+            name: fields.name,
+            prompt: fields.prompt,
+            engineOverride: fields.engineOverride,
+            timing,
+            enabled: fields.enabled ?? true,
+            nextFireAt: computeNextFireAt(timing, now),
+            history: [],
+        };
+        this.data.schedules.push(record);
+        this.save();
+        return { ...record };
+    }
+    update(id, patch) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        if (patch.name !== undefined)
+            record.name = patch.name;
+        if (patch.prompt !== undefined)
+            record.prompt = patch.prompt;
+        if (patch.engineOverride !== undefined) {
+            record.engineOverride = patch.engineOverride === null ? undefined : patch.engineOverride;
+        }
+        if (patch.enabled !== undefined)
+            record.enabled = patch.enabled;
+        if (patch.timing !== undefined) {
+            record.timing = clampTiming(patch.timing);
+            record.nextFireAt = computeNextFireAt(record.timing, new Date());
+        }
+        this.save();
+        return { ...record };
+    }
+    delete(id) {
+        const index = this.data.schedules.findIndex((s) => s.id === id);
+        if (index === -1)
+            return false;
+        this.data.schedules.splice(index, 1);
+        this.save();
+        return true;
+    }
+    setEnabled(id, enabled) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        record.enabled = enabled;
+        this.save();
+        return { ...record };
+    }
+    recordFire(id, entry, nextFireAt) {
+        const record = this.data.schedules.find((s) => s.id === id);
+        if (!record)
+            return undefined;
+        record.history.push(entry);
+        if (record.history.length > MAX_SCHEDULE_HISTORY) {
+            record.history.splice(0, record.history.length - MAX_SCHEDULE_HISTORY);
+        }
+        record.lastFire = { at: entry.at, tabId: entry.tabId, status: entry.status };
+        record.nextFireAt = nextFireAt;
+        this.save();
+        return { ...record };
+    }
+}

package/dist/server/services/schedule/agent-scheduler.js

@@ -0,0 +1,323 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import { ENGINE_EFFORT_LEVELS, engineForModel } from '../../engines/types.js';
+import { getEffortLevel, getEngine, getFastMode, getModel } from '../settings.js';
+import { resolveEngineForSession, runAcceptedExecute, setupSessionListeners } from '../websocket/session-handlers.js';
+import { AgentScheduleStore } from './agent-schedule-store.js';
+import { SCHEDULE_ONCE_GRACE_MS } from './scheduler.js';
+export const AGENT_SCHEDULER_TICK_MS = 30_000;
+export { SCHEDULE_ONCE_GRACE_MS };
+const SCHEDULER_HOST_WS = { send: () => { }, close: () => { }, readyState: 3 };
+export class AgentScheduledRunRegistry {
+    runs = new Map();
+    get(scheduleId) {
+        return this.runs.get(scheduleId);
+    }
+    has(scheduleId) {
+        return this.runs.has(scheduleId);
+    }
+    set(scheduleId, run) {
+        this.runs.set(scheduleId, run);
+    }
+    delete(scheduleId) {
+        this.runs.delete(scheduleId);
+    }
+    activeIds() {
+        return Array.from(this.runs.keys());
+    }
+    snapshotValues() {
+        return Array.from(this.runs.values());
+    }
+    reset() {
+        for (const run of this.runs.values())
+            run.settled = true;
+        this.runs.clear();
+    }
+}
+export class AgentSchedulerEngine {
+    workingDir;
+    runs = new AgentScheduledRunRegistry();
+    ctx;
+    deps;
+    tickIntervalMs;
+    timer = null;
+    store = null;
+    constructor(workingDir, ctx, deps = {}) {
+        this.workingDir = workingDir;
+        this.ctx = ctx;
+        this.deps = deps;
+        this.tickIntervalMs = deps.tickIntervalMs ?? AGENT_SCHEDULER_TICK_MS;
+    }
+    getStore() {
+        return this.store;
+    }
+    isRunning() {
+        return this.timer !== null;
+    }
+    start() {
+        if (this.timer)
+            return;
+        if (!this.workingDir)
+            return;
+        this.store = new AgentScheduleStore(this.workingDir);
+        this.tick();
+        this.timer = setInterval(() => this.tick(), this.tickIntervalMs);
+        if (typeof this.timer.unref === 'function')
+            this.timer.unref();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.runs.reset();
+        this.store = null;
+    }
+    tick() {
+        const store = this.store;
+        if (!store)
+            return;
+        this.reapFinishedRuns();
+        const now = Date.now();
+        for (const record of store.list()) {
+            if (!record.enabled)
+                continue;
+            if (this.runs.has(record.id)) {
+                if (this.isDue(record, now))
+                    this.recordSkippedOverlap(record, now);
+                continue;
+            }
+            if (isPastOnceAwaitingDecision(record)) {
+                this.resolvePastOnce(record, now);
+                continue;
+            }
+            if (!this.isDue(record, now))
+                continue;
+            this.fire(record, now);
+        }
+    }
+    isDue(record, now) {
+        if (!record.nextFireAt) {
+            return record.timing.kind === 'interval';
+        }
+        const at = parseEpoch(record.nextFireAt);
+        return Number.isFinite(at) && at <= now;
+    }
+    reapFinishedRuns() {
+        for (const run of this.runs.snapshotValues()) {
+            if (run.settled)
+                continue;
+            if (run.handle.isActive())
+                continue;
+            this.settle(run);
+        }
+    }
+    resolvePastOnce(record, now) {
+        if (record.timing.kind !== 'once')
+            return;
+        const at = parseEpoch(record.timing.at);
+        if (!Number.isFinite(at) || at > now)
+            return;
+        if (now - at <= SCHEDULE_ONCE_GRACE_MS) {
+            this.fire(record, now);
+            return;
+        }
+        const store = this.store;
+        if (!store)
+            return;
+        store.recordFire(record.id, {
+            at: new Date(now).toISOString(),
+            status: 'missed',
+            tabId: null,
+            error: 'missed by more than the 15 minute grace window',
+        }, null);
+        store.setEnabled(record.id, false);
+        this.broadcastSchedules();
+    }
+    fire(record, now) {
+        const store = this.store;
+        if (!store)
+            return;
+        const firedAt = new Date(now).toISOString();
+        let handle;
+        try {
+            handle = (this.deps.launch ?? launchScheduledAgentRun)(this.ctx, this.workingDir, record);
+        }
+        catch (error) {
+            this.recordFailedFire(record, firedAt, errorMessage(error));
+            return;
+        }
+        store.recordFire(record.id, { at: firedAt, status: 'started', tabId: handle.tabId }, this.nextFireAtAfterStart(record, now));
+        this.broadcastSchedules();
+        this.ctx.broadcastToAll({
+            type: 'agentScheduleFired',
+            data: { scheduleId: record.id, tabId: handle.tabId, tabName: handle.tabName, firedAt },
+        });
+        const run = { scheduleId: record.id, handle, startedAt: now, lastError: null, settled: false };
+        this.runs.set(record.id, run);
+        handle.onSettle((error) => {
+            run.lastError = error;
+            this.settle(run);
+        });
+    }
+    settle(run) {
+        if (run.settled)
+            return;
+        run.settled = true;
+        this.runs.delete(run.scheduleId);
+        const store = this.store;
+        const record = store?.get(run.scheduleId);
+        if (!store || !record)
+            return;
+        const now = Date.now();
+        store.recordFire(run.scheduleId, {
+            at: new Date(now).toISOString(),
+            status: run.lastError ? 'failed' : 'completed',
+            tabId: run.handle.tabId,
+            ...(run.lastError ? { error: run.lastError } : {}),
+        }, this.nextFireAtAfterSettle(record, now));
+        if (record.timing.kind === 'once')
+            store.setEnabled(run.scheduleId, false);
+        this.broadcastSchedules();
+    }
+    recordFailedFire(record, firedAt, error) {
+        const store = this.store;
+        if (!store)
+            return;
+        const now = parseEpoch(firedAt);
+        store.recordFire(record.id, { at: firedAt, status: 'failed', tabId: null, error }, this.nextFireAtAfterFailure(record, now));
+        if (record.timing.kind === 'once')
+            store.setEnabled(record.id, false);
+        this.broadcastSchedules();
+    }
+    recordSkippedOverlap(record, now) {
+        const store = this.store;
+        if (!store)
+            return;
+        store.recordFire(record.id, {
+            at: new Date(now).toISOString(),
+            status: 'skipped-overlap',
+            tabId: null,
+            error: 'previous run for this schedule is still executing',
+        }, this.nextFireAtAfterStart(record, now));
+        this.broadcastSchedules();
+    }
+    nextFireAtAfterStart(record, now) {
+        if (record.timing.kind === 'interval')
+            return new Date(now + record.timing.everyMs).toISOString();
+        return null;
+    }
+    nextFireAtAfterFailure(record, now) {
+        if (record.timing.kind === 'once')
+            return null;
+        return new Date(now + record.timing.everyMs).toISOString();
+    }
+    nextFireAtAfterSettle(record, now) {
+        if (record.timing.kind === 'once')
+            return null;
+        return this.store?.get(record.id)?.nextFireAt ?? new Date(now + record.timing.everyMs).toISOString();
+    }
+    broadcastSchedules() {
+        if (!this.store)
+            return;
+        this.ctx.broadcastToAll({ type: 'agentSchedulesChanged', data: { schedules: this.store.list() } });
+    }
+}
+export function machineDefaultRunTarget() {
+    const engine = getEngine();
+    const model = getModel();
+    const effortLevel = getEffortLevel();
+    return {
+        engine,
+        ...(model && engineForModel(model) === engine ? { model } : {}),
+        ...(ENGINE_EFFORT_LEVELS[engine].includes(effortLevel) ? { effortLevel } : {}),
+        fastMode: engine === 'claude-code' && getFastMode(),
+    };
+}
+export function launchScheduledAgentRun(ctx, workingDir, record) {
+    const registry = ctx.getRegistry(workingDir);
+    const tabId = `tab-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const session = new ImprovisationSessionManager({ workingDir });
+    setupSessionListeners(ctx, session, SCHEDULER_HOST_WS, tabId);
+    const sessionId = session.getSessionInfo().sessionId;
+    ctx.sessions.set(sessionId, session);
+    registry.registerTab(tabId, sessionId, record.name);
+    const override = record.engineOverride;
+    if (override) {
+        session.applyOverrides(override);
+        registry.updateTabEngineOverride(tabId, override);
+    }
+    else {
+        session.applyOverrides(machineDefaultRunTarget());
+    }
+    const registeredTab = registry.getTab(tabId);
+    const tabName = registeredTab?.tabName || record.name || 'Agent';
+    const engine = resolveEngineForSession(session);
+    ctx.broadcastToAll({
+        type: 'tabCreated',
+        engine,
+        data: {
+            tabId,
+            tabName,
+            createdAt: registeredTab?.createdAt,
+            order: registeredTab?.order,
+            engine,
+            sessionInfo: session.getSessionInfo(),
+        },
+    });
+    if (override) {
+        ctx.broadcastToAll({ type: 'tabEngineOverride', tabId, data: { tabId, override } });
+    }
+    let settledError;
+    let settleCallback = null;
+    const finish = (error) => {
+        if (settledError !== undefined)
+            return;
+        settledError = error;
+        settleCallback?.(error);
+    };
+    session.on('onMovementComplete', () => finish(null));
+    session.on('onMovementError', (error) => finish(error.message));
+    runAcceptedExecute(ctx, session, { prompt: record.prompt, ...(override ?? {}) }, tabId);
+    return {
+        tabId,
+        tabName,
+        onSettle(callback) {
+            settleCallback = callback;
+            if (settledError !== undefined)
+                callback(settledError);
+        },
+        isActive: () => ctx.sessions.get(sessionId) === session && session.isExecuting,
+    };
+}
+export const agentSchedulerCache = new Map();
+function parseEpoch(iso) {
+    return Date.parse(iso);
+}
+function isPastOnceAwaitingDecision(record) {
+    return record.timing.kind === 'once' && !record.nextFireAt && !record.lastFire;
+}
+function errorMessage(error) {
+    if (typeof error === 'string')
+        return error;
+    return error instanceof Error ? error.message : String(error);
+}
+export function getAgentScheduler(workingDir, ctx, deps) {
+    let engine = agentSchedulerCache.get(workingDir);
+    if (!engine) {
+        engine = new AgentSchedulerEngine(workingDir, ctx, deps);
+        agentSchedulerCache.set(workingDir, engine);
+    }
+    return engine;
+}
+export function stopAllAgentSchedulers() {
+    for (const engine of agentSchedulerCache.values()) {
+        try {
+            engine.stop();
+        }
+        catch {
+        }
+    }
+    agentSchedulerCache.clear();
+}

package/dist/server/services/schedule/daily-timing.js

@@ -0,0 +1,105 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const TIME_PATTERN = /^([01]\d|2[0-3]):[0-5]\d$/;
+const WEEKDAY_NAMES = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const CANDIDATE_DAYS = 8;
+const formatterCache = new Map();
+function zoneFormatter(timeZone) {
+    let formatter = formatterCache.get(timeZone);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hourCycle: 'h23',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            weekday: 'short',
+        });
+        formatterCache.set(timeZone, formatter);
+    }
+    return formatter;
+}
+export function isValidTimeZone(value) {
+    if (typeof value !== 'string' || value === '')
+        return false;
+    try {
+        zoneFormatter(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isWeekdayList(raw) {
+    return (Array.isArray(raw) &&
+        raw.length >= 1 &&
+        raw.length <= 7 &&
+        raw.every((day) => Number.isInteger(day) && day >= 0 && day <= 6));
+}
+export function isValidDailyTiming(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    const t = raw;
+    if (t.kind !== 'daily')
+        return false;
+    if (typeof t.time !== 'string' || !TIME_PATTERN.test(t.time))
+        return false;
+    if (!isValidTimeZone(t.timeZone))
+        return false;
+    if (t.days !== undefined && !isWeekdayList(t.days))
+        return false;
+    return true;
+}
+export function normalizeDailyTiming(raw) {
+    if (!isValidDailyTiming(raw))
+        return null;
+    const timing = { kind: 'daily', time: raw.time, timeZone: raw.timeZone };
+    if (raw.days)
+        timing.days = [...new Set(raw.days)].sort((a, b) => a - b);
+    return timing;
+}
+export function zonedParts(instant, timeZone) {
+    const parts = zoneFormatter(timeZone).formatToParts(new Date(instant));
+    const read = (type) => parts.find((part) => part.type === type)?.value ?? '0';
+    return {
+        year: Number(read('year')),
+        month: Number(read('month')),
+        day: Number(read('day')),
+        hour: Number(read('hour')) % 24,
+        minute: Number(read('minute')),
+        second: Number(read('second')),
+        weekday: Math.max(0, WEEKDAY_NAMES.indexOf(read('weekday'))),
+    };
+}
+export function zoneOffsetMs(instant, timeZone) {
+    const whole = Math.floor(instant / 1000) * 1000;
+    const p = zonedParts(whole, timeZone);
+    return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second) - whole;
+}
+export function instantForWallTime(year, month, day, hour, minute, timeZone) {
+    const guess = Date.UTC(year, month - 1, day, hour, minute);
+    const first = guess - zoneOffsetMs(guess, timeZone);
+    const second = guess - zoneOffsetMs(first, timeZone);
+    const landed = zonedParts(second, timeZone);
+    if (landed.hour === hour && landed.minute === minute)
+        return second;
+    return Math.max(first, second);
+}
+export function nextDailyFireAt(timing, from) {
+    const [hour, minute] = timing.time.split(':').map(Number);
+    const fromMs = from.getTime();
+    const today = zonedParts(fromMs, timing.timeZone);
+    for (let offset = 0; offset <= CANDIDATE_DAYS; offset++) {
+        const day = new Date(Date.UTC(today.year, today.month - 1, today.day + offset, 12));
+        const candidate = instantForWallTime(day.getUTCFullYear(), day.getUTCMonth() + 1, day.getUTCDate(), hour, minute, timing.timeZone);
+        if (candidate <= fromMs)
+            continue;
+        if (timing.days && !timing.days.includes(zonedParts(candidate, timing.timeZone).weekday))
+            continue;
+        return new Date(candidate).toISOString();
+    }
+    throw new Error(`no daily slot within ${CANDIDATE_DAYS} days for ${timing.time} in ${timing.timeZone}`);
+}

package/dist/server/services/schedule/quality-schedule-launch.js

@@ -0,0 +1,11 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { startScheduledQualityRun } from '../sdk/quality.js';
+import { operationRegistry } from '../websocket/quality-operations.js';
+export const SCHEDULE_INITIATOR = { appId: 'quality-schedule', origin: 'minion://quality-schedule' };
+export function isQualityPathBusy(workingDir, path) {
+    return operationRegistry.has(workingDir, path);
+}
+export function launchScheduledQualityRun(workingDir, target) {
+    return startScheduledQualityRun(workingDir, target.path, target.initiator ?? SCHEDULE_INITIATOR);
+}