minimal-agent 0.8.2 → 0.10.0

package/plugins/cron-runner/src/scheduler.js

@@ -0,0 +1,355 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { resolveSessionFile } from '../../../src/plugin-sdk.js';
+import { releaseSchedulerLock, tryAcquireSchedulerLock } from './lock.js';
+import { countScheduleSlots, latestScheduleRunMs, nextScheduleRunMs, } from './scheduleEngine.js';
+import { appendMissed, appendRun, cronLockFile, getTask, listTasks, subscribeTaskChanges, updateTask, } from './store.js';
+const RECONCILE_MS = 30_000;
+export class Scheduler {
+    ctx;
+    dueTimer = null;
+    reconcileTimer = null;
+    unsubscribeStore = null;
+    executions = new Map();
+    executionController = new AbortController();
+    owner = `cron-runner-${process.pid}-${randomUUID()}`;
+    ownsLock = false;
+    started = false;
+    stopping = false;
+    reconciling = false;
+    initializing = false;
+    stopPromise = null;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.stopping = false;
+        this.unsubscribeStore = subscribeTaskChanges(() => this.wake());
+        void this.startAsync();
+    }
+    async stop() {
+        if (this.stopPromise)
+            return await this.stopPromise;
+        if (!this.started && !this.ownsLock && this.executions.size === 0)
+            return;
+        this.started = false;
+        this.stopping = true;
+        this.executionController.abort('cron scheduler stopped');
+        this.clearTimers();
+        this.unsubscribeStore?.();
+        this.unsubscribeStore = null;
+        this.stopPromise = (async () => {
+            await Promise.allSettled([...this.executions.values()]);
+            if (!this.ownsLock)
+                return;
+            this.ownsLock = false;
+            await releaseSchedulerLock(cronLockFile(), this.owner);
+        })();
+        await this.stopPromise;
+    }
+    async runTaskNow(id) {
+        if (this.stopping || this.executions.has(id))
+            return;
+        const task = await getTask(id);
+        if (!task)
+            return;
+        await this.launchTask(task);
+    }
+    async isActiveScheduler() {
+        return this.ownsLock;
+    }
+    wake() {
+        if (!this.ownsLock || this.stopping || this.initializing)
+            return;
+        if (this.dueTimer)
+            clearTimeout(this.dueTimer);
+        this.dueTimer = setTimeout(() => void this.reconcile(), 0);
+        this.dueTimer.unref?.();
+    }
+    async startAsync() {
+        this.initializing = true;
+        this.ownsLock = await tryAcquireSchedulerLock(cronLockFile(), this.owner);
+        if (!this.ownsLock) {
+            this.initializing = false;
+            return;
+        }
+        if (this.stopping) {
+            this.ownsLock = false;
+            await releaseSchedulerLock(cronLockFile(), this.owner);
+            this.initializing = false;
+            return;
+        }
+        await this.recordMissedTasks();
+        this.initializing = false;
+        this.reconcileTimer = setInterval(() => void this.reconcile(), RECONCILE_MS);
+        this.reconcileTimer.unref?.();
+        await this.reconcile();
+    }
+    clearTimers() {
+        if (this.dueTimer)
+            clearTimeout(this.dueTimer);
+        if (this.reconcileTimer)
+            clearInterval(this.reconcileTimer);
+        this.dueTimer = null;
+        this.reconcileTimer = null;
+    }
+    async reconcile() {
+        if (!this.ownsLock || this.stopping || this.reconciling)
+            return;
+        this.reconciling = true;
+        try {
+            const now = Date.now();
+            const tasks = await listTasks();
+            for (const task of tasks)
+                await this.processDueTask(task, now);
+            await this.armNextTimer();
+        }
+        finally {
+            this.reconciling = false;
+        }
+    }
+    async processDueTask(task, now) {
+        if (task.status !== 'active')
+            return;
+        if (task.runtime.bindingStatus !== 'bound')
+            return;
+        if (this.isExpired(task, now)) {
+            await updateTask(task.id, (latest) => ({ ...latest, status: 'completed' }));
+            return;
+        }
+        const baseMs = this.lastProcessedMs(task);
+        const jitterMs = task.schedule.jitterMs ?? 0;
+        const latestDue = latestScheduleRunMs(task.schedule, now - jitterMs);
+        if (!latestDue || latestDue <= baseMs)
+            return;
+        const dueCount = countScheduleSlots(task.schedule, baseMs, latestDue);
+        if (dueCount === 0)
+            return;
+        if (this.executions.has(task.id)) {
+            await this.markMissed(task, latestDue, dueCount, 'overlap');
+            return;
+        }
+        // If the event loop was delayed across several slots, run only the latest
+        // and record all older slots. This keeps skip semantics deterministic.
+        if (dueCount > 1)
+            await this.appendMissed(task, latestDue, dueCount - 1, 'offline');
+        const claimed = await updateTask(task.id, (latest) => ({
+            ...latest,
+            schedule: {
+                ...latest.schedule,
+                lastScheduledFor: new Date(latestDue).toISOString(),
+                lastFiredAt: new Date().toISOString(),
+            },
+            stats: {
+                ...latest.stats,
+                skippedCount: latest.stats.skippedCount + Math.max(0, dueCount - 1),
+            },
+        }));
+        if (claimed && !this.stopping)
+            void this.launchTask(claimed, new Date(latestDue).toISOString());
+    }
+    async recordMissedTasks() {
+        const now = Date.now();
+        for (const task of await listTasks()) {
+            if (task.status !== 'active')
+                continue;
+            const baseMs = this.lastProcessedMs(task);
+            const latestDue = latestScheduleRunMs(task.schedule, now - (task.schedule.jitterMs ?? 0));
+            if (!latestDue || latestDue <= baseMs)
+                continue;
+            const missedCount = countScheduleSlots(task.schedule, baseMs, latestDue);
+            if (missedCount > 0)
+                await this.markMissed(task, latestDue, missedCount, 'offline');
+        }
+    }
+    async markMissed(task, latestDue, missedCount, reason) {
+        await this.appendMissed(task, latestDue, missedCount, reason);
+        await updateTask(task.id, (latest) => ({
+            ...latest,
+            ...(latest.kind === 'once' ? { status: 'paused' } : {}),
+            schedule: {
+                ...latest.schedule,
+                lastScheduledFor: new Date(latestDue).toISOString(),
+            },
+            stats: {
+                ...latest.stats,
+                skippedCount: latest.stats.skippedCount + missedCount,
+            },
+        }));
+    }
+    async appendMissed(task, latestDue, missedCount, reason) {
+        await appendMissed({
+            id: `missed-${randomUUID().slice(0, 8)}`,
+            taskId: task.id,
+            taskName: task.name,
+            scheduledFor: new Date(latestDue).toISOString(),
+            detectedAt: new Date().toISOString(),
+            actionPreview: actionPreview(task),
+            reason,
+            missedCount,
+        });
+    }
+    async armNextTimer() {
+        if (!this.ownsLock || this.stopping)
+            return;
+        if (this.dueTimer)
+            clearTimeout(this.dueTimer);
+        let earliest = Number.POSITIVE_INFINITY;
+        for (const task of await listTasks()) {
+            if (task.status !== 'active' || this.isExpired(task, Date.now()))
+                continue;
+            const next = nextScheduleRunMs(task.schedule, this.lastProcessedMs(task));
+            if (next)
+                earliest = Math.min(earliest, next + (task.schedule.jitterMs ?? 0));
+        }
+        if (!Number.isFinite(earliest)) {
+            this.dueTimer = null;
+            return;
+        }
+        const delay = Math.max(0, earliest - Date.now());
+        this.dueTimer = setTimeout(() => void this.reconcile(), delay);
+        this.dueTimer.unref?.();
+    }
+    lastProcessedMs(task) {
+        const raw = task.schedule.lastScheduledFor ?? task.createdAt;
+        const parsed = Date.parse(raw);
+        return Number.isFinite(parsed) ? parsed : Date.now();
+    }
+    isExpired(task, now) {
+        return Boolean(task.expiresAt && !task.permanent && Date.parse(task.expiresAt) <= now);
+    }
+    launchTask(task, scheduledFor) {
+        if (this.executions.has(task.id))
+            return this.executions.get(task.id);
+        const execution = this.runTask(task, scheduledFor).finally(() => {
+            this.executions.delete(task.id);
+            this.wake();
+        });
+        this.executions.set(task.id, execution);
+        return execution;
+    }
+    async runTask(task, scheduledFor) {
+        const started = Date.now();
+        // Session 绑定失效表示本次根本没有执行。它属于 missed/needs_binding，而不是一次
+        // Agent failure；否则会消耗 maxRuns，并让用户误以为模型真正跑过。
+        if (task.runtime.sessionMode !== 'fresh' && !existsSync(await resolveSessionFile(task.runtime.cwd, task.runtime.sessionId))) {
+            const detectedAt = new Date().toISOString();
+            await updateTask(task.id, (latest) => ({
+                ...latest,
+                runtime: { ...latest.runtime, bindingStatus: 'needs_binding' },
+                ...(latest.status === 'active' ? { status: 'paused' } : {}),
+                stats: {
+                    ...latest.stats,
+                    skippedCount: latest.stats.skippedCount + (scheduledFor ? 1 : 0),
+                },
+            }));
+            await appendMissed({
+                id: `missed-${randomUUID().slice(0, 8)}`,
+                taskId: task.id,
+                taskName: task.name,
+                scheduledFor: scheduledFor ?? detectedAt,
+                detectedAt,
+                actionPreview: actionPreview(task),
+                reason: 'binding_unavailable',
+                missedCount: 1,
+            });
+            return;
+        }
+        const run = {
+            id: `run-${randomUUID().slice(0, 8)}`,
+            taskId: task.id,
+            taskName: task.name,
+            ...(scheduledFor ? { scheduledFor } : {}),
+            startedAt: new Date(started).toISOString(),
+            status: 'running',
+            cwd: task.runtime.cwd,
+            sessionId: task.runtime.sessionId,
+            ...(task.runtime.model ? { model: task.runtime.model } : {}),
+        };
+        await appendRun(run);
+        try {
+            const input = task.action.type === 'workflow'
+                ? `/workflow ${task.action.command}`
+                : task.action.prompt;
+            const sessionId = task.runtime.sessionId;
+            const result = await this.ctx.runAgentTurn({
+                input,
+                provider: this.ctx.provider,
+                cwd: task.runtime.cwd,
+                sessionId,
+                maxTurns: task.runtime.maxTurns,
+                model: task.runtime.model,
+                signal: combineSignals(this.ctx.signal, this.executionController.signal),
+            });
+            const executionOk = result.ok && !this.executionController.signal.aborted;
+            const executionError = this.executionController.signal.aborted
+                ? 'cron scheduler stopped during execution'
+                : result.error;
+            const finishedAt = new Date().toISOString();
+            await updateTask(task.id, (latest) => ({
+                ...latest,
+                ...(reachedRunLimit(latest, latest.stats.runCount + 1)
+                    ? { status: 'completed' }
+                    : {}),
+                stats: {
+                    ...latest.stats,
+                    runCount: latest.stats.runCount + 1,
+                    successCount: latest.stats.successCount + (executionOk ? 1 : 0),
+                    failureCount: latest.stats.failureCount + (executionOk ? 0 : 1),
+                    lastRunAt: finishedAt,
+                    ...(executionOk ? { lastSuccessAt: finishedAt } : { lastFailureAt: finishedAt }),
+                },
+            }));
+            await appendRun({
+                ...run,
+                finishedAt,
+                status: executionOk ? 'success' : 'failure',
+                durationMs: Date.now() - started,
+                resultPreview: result.result.slice(0, 1000),
+                ...(!executionOk ? { attentionReason: 'failure' } : {}),
+                ...(executionError ? { error: executionError } : {}),
+            });
+        }
+        catch (err) {
+            const finishedAt = new Date().toISOString();
+            await updateTask(task.id, (latest) => ({
+                ...latest,
+                ...(reachedRunLimit(latest, latest.stats.runCount + 1)
+                    ? { status: 'completed' }
+                    : {}),
+                stats: {
+                    ...latest.stats,
+                    runCount: latest.stats.runCount + 1,
+                    failureCount: latest.stats.failureCount + 1,
+                    lastRunAt: finishedAt,
+                    lastFailureAt: finishedAt,
+                },
+            }));
+            await appendRun({
+                ...run,
+                finishedAt,
+                status: 'failure',
+                durationMs: Date.now() - started,
+                attentionReason: 'failure',
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+function reachedRunLimit(task, nextRunCount) {
+    if (task.kind === 'once')
+        return true;
+    return typeof task.maxRuns === 'number' && task.maxRuns > 0 && nextRunCount >= task.maxRuns;
+}
+function actionPreview(task) {
+    const text = task.action.type === 'workflow'
+        ? `/workflow ${task.action.command}`
+        : task.action.prompt;
+    return text.length > 160 ? `${text.slice(0, 157)}...` : text;
+}
+function combineSignals(parent, local) {
+    return parent ? AbortSignal.any([parent, local]) : local;
+}

package/plugins/cron-runner/src/schema.js

@@ -0,0 +1,140 @@
+import { cronToHuman, nextCronRunMs, parseCronExpression } from './cronTime.js';
+import { intervalToHuman, MIN_INTERVAL_MS } from './scheduleEngine.js';
+export function validateCron(cron) {
+    const parsed = parseCronExpression(cron);
+    if (!parsed)
+        return { ok: false, error: 'cron 必须是合法的 5 字段表达式。' };
+    if (nextCronRunMs(cron) === null) {
+        return { ok: false, error: 'cron 在未来一年内没有可运行时间。' };
+    }
+    return { ok: true };
+}
+export function validateIsoDate(value, field) {
+    const time = Date.parse(value);
+    if (!Number.isFinite(time))
+        return { ok: false, error: `${field} 必须是 ISO 时间。` };
+    return { ok: true };
+}
+export function normalizeTask(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const task = raw;
+    if (typeof task.id !== 'string' || !task.id)
+        return null;
+    if (typeof task.name !== 'string' || !task.name)
+        return null;
+    if (task.status !== 'active' && task.status !== 'paused' && task.status !== 'completed')
+        return null;
+    if (!task.schedule || typeof task.schedule !== 'object')
+        return null;
+    const schedule = task.schedule;
+    const scheduleType = schedule.type === 'interval' ? 'interval' : 'cron';
+    if (scheduleType === 'cron') {
+        if (typeof schedule.cron !== 'string' || !parseCronExpression(schedule.cron))
+            return null;
+    }
+    else if (typeof schedule.intervalMs !== 'number' ||
+        schedule.intervalMs < MIN_INTERVAL_MS ||
+        typeof schedule.anchorAt !== 'string' ||
+        !Number.isFinite(Date.parse(schedule.anchorAt))) {
+        return null;
+    }
+    if (!task.action || typeof task.action !== 'object')
+        return null;
+    const action = task.action;
+    if (action.type === 'prompt') {
+        if (typeof action.prompt !== 'string' || !action.prompt)
+            return null;
+    }
+    else if (action.type === 'workflow') {
+        if (typeof action.command !== 'string' || !action.command)
+            return null;
+    }
+    else {
+        return null;
+    }
+    if (!task.runtime || typeof task.runtime !== 'object')
+        return null;
+    const runtime = task.runtime;
+    if (typeof runtime.cwd !== 'string' || !runtime.cwd)
+        return null;
+    if (runtime.environment && runtime.environment !== 'project')
+        return null;
+    const now = new Date().toISOString();
+    const kind = task.kind === 'once' ? 'once' : 'recurring';
+    const timezone = typeof schedule.timezone === 'string' && schedule.timezone
+        ? schedule.timezone
+        : Intl.DateTimeFormat().resolvedOptions().timeZone || 'local';
+    const stats = task.stats ?? {
+        runCount: 0,
+        successCount: 0,
+        failureCount: 0,
+    };
+    const legacyNeedsBinding = runtime.sessionMode === 'fresh' ||
+        typeof runtime.sessionId !== 'string' ||
+        !runtime.sessionId ||
+        runtime.sessionId.startsWith('cron-');
+    const bindingStatus = runtime.bindingStatus === 'needs_binding' || legacyNeedsBinding
+        ? 'needs_binding'
+        : 'bound';
+    return {
+        id: task.id,
+        name: task.name,
+        ...(typeof task.description === 'string' && task.description
+            ? { description: task.description }
+            : {}),
+        status: bindingStatus === 'needs_binding' && task.status === 'active' ? 'paused' : task.status,
+        kind,
+        ...(task.permanent ? { permanent: true } : {}),
+        ...(typeof task.expiresAt === 'string' ? { expiresAt: task.expiresAt } : {}),
+        ...(typeof task.maxRuns === 'number' && task.maxRuns > 0 ? { maxRuns: task.maxRuns } : {}),
+        schedule: scheduleType === 'interval' ? {
+            type: 'interval',
+            intervalMs: schedule.intervalMs,
+            anchorAt: schedule.anchorAt,
+            human: intervalToHuman(schedule.intervalMs),
+            ...(typeof schedule.nextRunAt === 'string' ? { nextRunAt: schedule.nextRunAt } : {}),
+            ...(typeof schedule.lastFiredAt === 'string' ? { lastFiredAt: schedule.lastFiredAt } : {}),
+            ...(typeof schedule.lastScheduledFor === 'string'
+                ? { lastScheduledFor: schedule.lastScheduledFor }
+                : {}),
+            ...(typeof schedule.jitterMs === 'number' ? { jitterMs: schedule.jitterMs } : {}),
+        } : {
+            type: 'cron',
+            cron: schedule.cron,
+            timezone,
+            human: cronToHuman(schedule.cron),
+            ...(typeof schedule.nextRunAt === 'string' ? { nextRunAt: schedule.nextRunAt } : {}),
+            ...(typeof schedule.lastFiredAt === 'string' ? { lastFiredAt: schedule.lastFiredAt } : {}),
+            ...(typeof schedule.lastScheduledFor === 'string'
+                ? { lastScheduledFor: schedule.lastScheduledFor }
+                : {}),
+            ...(typeof schedule.jitterMs === 'number' ? { jitterMs: schedule.jitterMs } : {}),
+        },
+        action,
+        runtime: {
+            cwd: runtime.cwd,
+            environment: 'project',
+            sessionId: typeof runtime.sessionId === 'string' && runtime.sessionId
+                ? runtime.sessionId
+                : `cron-${task.id}`,
+            sessionMode: bindingStatus === 'bound' ? 'persistent' : (runtime.sessionMode === 'fresh' ? 'fresh' : 'persistent'),
+            bindingStatus,
+            ...(typeof runtime.model === 'string' && runtime.model ? { model: runtime.model } : {}),
+            ...(typeof runtime.maxTurns === 'number' && runtime.maxTurns > 0
+                ? { maxTurns: runtime.maxTurns }
+                : {}),
+        },
+        stats: {
+            runCount: typeof stats.runCount === 'number' ? stats.runCount : 0,
+            successCount: typeof stats.successCount === 'number' ? stats.successCount : 0,
+            failureCount: typeof stats.failureCount === 'number' ? stats.failureCount : 0,
+            skippedCount: typeof stats.skippedCount === 'number' ? stats.skippedCount : 0,
+            ...(typeof stats.lastRunAt === 'string' ? { lastRunAt: stats.lastRunAt } : {}),
+            ...(typeof stats.lastSuccessAt === 'string' ? { lastSuccessAt: stats.lastSuccessAt } : {}),
+            ...(typeof stats.lastFailureAt === 'string' ? { lastFailureAt: stats.lastFailureAt } : {}),
+        },
+        createdAt: typeof task.createdAt === 'string' ? task.createdAt : now,
+        updatedAt: typeof task.updatedAt === 'string' ? task.updatedAt : now,
+    };
+}

package/plugins/cron-runner/src/service.js

@@ -0,0 +1,167 @@
+import { randomUUID } from 'node:crypto';
+import { parseShortcutSchedule } from './commands.js';
+import { validateCron } from './schema.js';
+import { createTask, listMissed, listTasks, markMissedRead, markRunsRead, patchTask, recentRuns, upsertTask, } from './store.js';
+import { cronToHuman } from './cronTime.js';
+import { intervalToHuman, nextScheduleRunMs } from './scheduleEngine.js';
+export function draftCronFromText(text, context, requestId = randomUUID()) {
+    const normalized = normalizeScheduleText(text);
+    const [head = '', ...rest] = tokenize(normalized.replace(/^\/cron\s*/i, ''));
+    const parsed = parseShortcutSchedule(head, rest);
+    const missing = [];
+    if (!context.cwd)
+        missing.push('workspace');
+    if (!context.sessionId)
+        missing.push('session');
+    if (!head || !parsed)
+        missing.push('schedule');
+    if (parsed && 'error' in parsed) {
+        if (parsed.error.includes('提示词') || parsed.error.includes('workflow'))
+            missing.push('action');
+        return { requestId, task: null, missing: unique(missing), error: parsed.error };
+    }
+    if (!parsed || !context.cwd || !context.sessionId) {
+        return { requestId, task: null, missing: unique(missing) };
+    }
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'local';
+    const task = {
+        name: parsed.name,
+        ...(parsed.description ? { description: parsed.description } : {}),
+        status: 'active',
+        kind: 'recurring',
+        schedule: parsed.cron
+            ? { type: 'cron', cron: parsed.cron, timezone, jitterMs: 0 }
+            : { type: 'interval', intervalMs: parsed.intervalMs, anchorAt: new Date().toISOString(), jitterMs: 0 },
+        action: parsed.action,
+        runtime: {
+            cwd: context.cwd,
+            sessionId: context.sessionId,
+            sessionMode: 'persistent',
+            ...(context.model ? { model: context.model } : {}),
+        },
+    };
+    const previewSchedule = task.schedule.type === 'cron'
+        ? { ...task.schedule, human: cronToHuman(task.schedule.cron) }
+        : { ...task.schedule, anchorAt: task.schedule.anchorAt, human: intervalToHuman(task.schedule.intervalMs) };
+    const next = nextScheduleRunMs(previewSchedule, Date.now());
+    return {
+        requestId,
+        task,
+        missing: [],
+        scheduleHuman: previewSchedule.human,
+        ...(next ? { nextRunAt: new Date(next).toISOString() } : {}),
+    };
+}
+export async function createCronFromDraft(draft) {
+    assertDraft(draft);
+    const task = createTask({
+        name: draft.name.trim(),
+        ...(draft.description?.trim() ? { description: draft.description.trim() } : {}),
+        ...(draft.schedule.type === 'cron'
+            ? { cron: draft.schedule.cron, timezone: draft.schedule.timezone }
+            : {
+                intervalMs: draft.schedule.intervalMs,
+                anchorAt: draft.schedule.anchorAt,
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'local',
+            }),
+        cwd: draft.runtime.cwd,
+        sessionId: draft.runtime.sessionId,
+        sessionMode: 'persistent',
+        model: draft.runtime.model,
+        maxTurns: draft.runtime.maxTurns,
+        kind: draft.kind,
+        permanent: draft.permanent,
+        expiresAt: draft.expiresAt,
+        maxRuns: draft.maxRuns,
+        jitterMs: draft.schedule.jitterMs ?? 0,
+        action: draft.action,
+    });
+    task.status = draft.status;
+    return await upsertTask(task);
+}
+export async function updateCronFromPatch(patch) {
+    if (!patch.id)
+        throw new Error('缺少定时任务 ID');
+    if (patch.schedule?.type === 'cron') {
+        const checked = validateCron(patch.schedule.cron);
+        if (!checked.ok)
+            throw new Error(checked.error);
+    }
+    const task = await patchTask(patch);
+    if (!task)
+        throw new Error(`未找到定时任务：${patch.id}`);
+    if (task.runtime.bindingStatus !== 'bound' && patch.status === 'active') {
+        throw new Error('请先重新绑定工作目录会话');
+    }
+    return task;
+}
+export async function listCronTasks(filter = {}) {
+    const query = filter.query?.trim().toLocaleLowerCase();
+    const missed = await listMissed(500);
+    const missedTaskIds = new Set(missed.filter((item) => !item.readAt).map((item) => item.taskId));
+    const rows = await Promise.all((await listTasks()).map(async (task) => {
+        const runs = await recentRuns(task.id, 20);
+        const unreadCount = runs.filter((run) => !run.readAt && (run.status === 'failure' || run.attentionReason)).length
+            + (missedTaskIds.has(task.id) ? 1 : 0);
+        return { task, recentRuns: runs, unreadCount };
+    }));
+    return rows.filter(({ task, unreadCount }) => {
+        if (filter.cwd && task.runtime.cwd !== filter.cwd)
+            return false;
+        if (filter.sessionId && task.runtime.sessionId !== filter.sessionId)
+            return false;
+        if (filter.status && filter.status !== 'all') {
+            if (filter.status === 'attention' ? unreadCount === 0 : task.status !== filter.status)
+                return false;
+        }
+        if (!query)
+            return true;
+        const haystack = [task.name, task.description, task.action.type === 'prompt' ? task.action.prompt : task.action.command]
+            .filter(Boolean).join(' ').toLocaleLowerCase();
+        return haystack.includes(query);
+    });
+}
+export async function markCronRead(taskId) {
+    await Promise.all([markRunsRead(taskId), markMissedRead(taskId)]);
+}
+function assertDraft(draft) {
+    if (!draft.name.trim())
+        throw new Error('请输入任务名称');
+    if (!draft.runtime.cwd)
+        throw new Error('请选择工作目录');
+    if (!draft.runtime.sessionId)
+        throw new Error('请选择绑定会话');
+    if (draft.runtime.sessionMode === 'fresh')
+        throw new Error('新任务必须绑定原会话');
+    if (draft.schedule.type === 'cron') {
+        const checked = validateCron(draft.schedule.cron);
+        if (!checked.ok)
+            throw new Error(checked.error);
+    }
+    else if (!Number.isFinite(draft.schedule.intervalMs) || draft.schedule.intervalMs < 60_000) {
+        throw new Error('固定间隔最短为 1 分钟');
+    }
+    if (draft.action.type === 'prompt' ? !draft.action.prompt.trim() : !draft.action.command.trim()) {
+        throw new Error('请输入执行内容');
+    }
+}
+function normalizeScheduleText(value) {
+    return value.trim()
+        .replace(/^请(?:帮我)?/u, '')
+        .replace(/每个工作日(?:的)?(?:早上|上午)?\s*/u, '工作日 ')
+        .replace(/每天(?:的)?(?:早上|上午)?\s*/u, '每天 ')
+        .replace(/每周([一二三四五六日天])(?:的)?(?:早上|上午)?\s*/u, '每周$1 ')
+        .replace(/每隔\s*(\d+)\s*分钟/u, '$1m')
+        .replace(/每隔\s*(\d+)\s*小时/u, '$1h')
+        .replace(/每隔\s*(\d+)\s*天/u, '$1d')
+        .replace(/早上\s*(\d{1,2})[点时](\d{1,2})?分?/u, (_, h, m) => `${h}:${m ?? '00'}`)
+        .replace(/(\d{1,2})[点时](\d{1,2})分/u, '$1:$2')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function tokenize(input) {
+    return input.match(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\S+/g)?.map((item) => item.replace(/^['"]|['"]$/g, '')) ?? [];
+}
+function unique(items) {
+    return [...new Set(items)];
+}