minimal-agent 0.10.0 → 0.12.0

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

@@ -0,0 +1,193 @@
+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 type {
+  CronListFilter,
+  CronTask,
+  CronTaskDraft,
+  CronTaskPatch,
+} from './types.js';
+import { cronToHuman } from './cronTime.js';
+import { intervalToHuman, nextScheduleRunMs } from './scheduleEngine.js';
+
+export interface CronDraftContext {
+  cwd: string;
+  sessionId: string;
+  model?: string;
+}
+
+export interface CronDraftResult {
+  requestId: string;
+  task: CronTaskDraft | null;
+  missing: Array<'workspace' | 'session' | 'schedule' | 'action'>;
+  error?: string;
+  scheduleHuman?: string;
+  nextRunAt?: string;
+}
+
+export function draftCronFromText(
+  text: string,
+  context: Partial<CronDraftContext>,
+  requestId: string = randomUUID(),
+): CronDraftResult {
+  const normalized = normalizeScheduleText(text);
+  const [head = '', ...rest] = tokenize(normalized.replace(/^\/cron\s*/i, ''));
+  const parsed = parseShortcutSchedule(head, rest);
+  const missing: CronDraftResult['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: CronTaskDraft = {
+    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: CronTaskDraft): Promise<CronTask> {
+  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: CronTaskPatch): Promise<CronTask> {
+  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: CronListFilter = {}) {
+  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?: string): Promise<void> {
+  await Promise.all([markRunsRead(taskId), markMissedRead(taskId)]);
+}
+
+function assertDraft(draft: CronTaskDraft): void {
+  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: string): string {
+  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: string): string[] {
+  return input.match(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\S+/g)?.map((item) => item.replace(/^['"]|['"]$/g, '')) ?? [];
+}
+
+function unique<T>(items: T[]): T[] {
+  return [...new Set(items)];
+}

package/plugins/cron-runner/src/store.ts

@@ -0,0 +1,333 @@
+import { randomUUID } from 'node:crypto';
+import { constants, copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import type { CronMissedRecord, CronRunRecord, CronTask, CronTaskFile, CronTaskPatch } from './types.js';
+import { cronToHuman } from './cronTime.js';
+import { intervalToHuman, nextScheduleRunMs } from './scheduleEngine.js';
+import { schedulerLockFile } from './lock.js';
+import { appendMissed as appendMissedRecord, appendRun as appendRunRecord, listMissed as listMissedRecords, markMissedRead as markMissedRecordsRead, markRunsRead as markRunRecordsRead, recentRuns as readRecentRuns } from './runs.js';
+import { normalizeTask } from './schema.js';
+
+function root(): string {
+  return process.env.MINIMAL_AGENT_CRON_RUNNER_HOME
+    ? join(process.env.MINIMAL_AGENT_CRON_RUNNER_HOME, 'cron-runner')
+    : join(homedir(), '.minimal-agent', 'plugins', 'cron-runner');
+}
+
+function tasksFile(): string {
+  return join(root(), 'tasks.json');
+}
+
+function runsDir(): string {
+  return join(root(), 'runs');
+}
+
+function missedFile(): string {
+  return join(root(), 'missed.jsonl');
+}
+
+let mutationQueue: Promise<void> = Promise.resolve();
+const taskChangeListeners = new Set<() => void>();
+
+function notifyTaskChanges(): void {
+  for (const listener of taskChangeListeners) listener();
+}
+
+export function subscribeTaskChanges(listener: () => void): () => void {
+  taskChangeListeners.add(listener);
+  return () => taskChangeListeners.delete(listener);
+}
+
+export function cronDataRoot(): string {
+  return root();
+}
+
+export function cronLockFile(): string {
+  return schedulerLockFile(root());
+}
+
+/** Upgrade legacy fresh/hidden-session tasks once, keeping an immutable pre-migration backup. */
+export async function migrateCronTasks(): Promise<boolean> {
+  return await enqueueMutation(async () => {
+    let raw: string;
+    try { raw = await readFile(tasksFile(), 'utf8'); } catch { return false; }
+    let parsed: Partial<CronTaskFile>;
+    try { parsed = JSON.parse(raw) as Partial<CronTaskFile>; } catch { return false; }
+    if (!Array.isArray(parsed.tasks)) return false;
+    const needsMigration = parsed.tasks.some((value) => {
+      const task = value as Partial<CronTask>;
+      return !task.schedule || !('type' in task.schedule) || !task.runtime?.bindingStatus || task.runtime.sessionMode === 'fresh' || task.runtime.sessionId?.startsWith('cron-');
+    });
+    if (!needsMigration) return false;
+    await mkdir(root(), { recursive: true });
+    try { await copyFile(tasksFile(), join(root(), 'tasks.pre-session-binding.backup.json'), constants.COPYFILE_EXCL); } catch { /* existing backup is intentionally retained */ }
+    const migrated = parsed.tasks.map(normalizeTask).filter((task): task is CronTask => Boolean(task));
+    await writeTasksFile(migrated);
+    notifyTaskChanges();
+    return true;
+  });
+}
+
+async function readTasks(fromMs = Date.now()): Promise<CronTask[]> {
+  try {
+    const raw = await readFile(tasksFile(), 'utf8');
+    const parsed = JSON.parse(raw) as Partial<CronTaskFile>;
+    return Array.isArray(parsed.tasks)
+      ? parsed.tasks
+          .map(normalizeTask)
+          .filter((task): task is CronTask => Boolean(task))
+          // 注意：不能写成 .map(refreshNextRun)——Array.map 会把 (element, index, array)
+          // 全传进去，第二个实参 index(0,1,2...) 会顶掉 refreshNextRun 的 fromMs=Date.now()
+          // 默认值，导致 nextRunAt/expired 全按 Unix 纪元(≈0ms)计算（真机 e2e 抓到
+          // nextRunAt 恒为 1970-01-01）。必须用箭头包一层只透传 task。
+          .map((task) => refreshNextRun(task, fromMs))
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+export async function listTasks(): Promise<CronTask[]> {
+  return await readTasks();
+}
+
+async function writeTasksFile(tasks: CronTask[]): Promise<void> {
+  const file = tasksFile();
+  await mkdir(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(
+    tmp,
+    JSON.stringify({ tasks: tasks.map((task) => refreshNextRun(task)) }, null, 2),
+    'utf8',
+  );
+  await rename(tmp, file);
+}
+
+function enqueueMutation<T>(mutate: () => Promise<T>): Promise<T> {
+  const operation = mutationQueue.then(mutate, mutate);
+  mutationQueue = operation.then(() => undefined, () => undefined);
+  return operation;
+}
+
+export async function writeTasks(tasks: CronTask[]): Promise<void> {
+  await enqueueMutation(async () => {
+    await writeTasksFile(tasks);
+    notifyTaskChanges();
+  });
+}
+
+export async function upsertTask(task: CronTask): Promise<CronTask> {
+  return await enqueueMutation(async () => {
+    const tasks = await readTasks();
+    const idx = tasks.findIndex((t) => t.id === task.id);
+    const saved = refreshNextRun({ ...task, updatedAt: new Date().toISOString() });
+    if (idx >= 0) tasks[idx] = saved;
+    else tasks.push(saved);
+    await writeTasksFile(tasks);
+    notifyTaskChanges();
+    return saved;
+  });
+}
+
+export async function updateTask(
+  id: string,
+  updater: (task: CronTask) => CronTask,
+): Promise<CronTask | undefined> {
+  return await enqueueMutation(async () => {
+    const tasks = await readTasks();
+    const idx = tasks.findIndex((task) => task.id === id);
+    if (idx < 0) return undefined;
+    const saved = refreshNextRun({
+      ...updater(tasks[idx]!),
+      updatedAt: new Date().toISOString(),
+    });
+    tasks[idx] = saved;
+    await writeTasksFile(tasks);
+    notifyTaskChanges();
+    return saved;
+  });
+}
+
+export async function deleteTask(id: string): Promise<boolean> {
+  return await enqueueMutation(async () => {
+    const tasks = await readTasks();
+    const next = tasks.filter((t) => t.id !== id);
+    if (next.length === tasks.length) return false;
+    await writeTasksFile(next);
+    notifyTaskChanges();
+    return true;
+  });
+}
+
+export async function getTask(idOrPrefix: string): Promise<CronTask | undefined> {
+  const tasks = await listTasks();
+  return tasks.find((t) => t.id === idOrPrefix) ?? tasks.find((t) => t.id.startsWith(idOrPrefix));
+}
+
+export async function appendRun(record: CronRunRecord): Promise<void> {
+  await appendRunRecord(runsDir(), record);
+}
+
+export async function recentRuns(taskId: string, limit = 5): Promise<CronRunRecord[]> {
+  return await readRecentRuns(runsDir(), taskId, limit);
+}
+
+export async function markRunsRead(taskId?: string): Promise<void> {
+  await markRunRecordsRead(runsDir(), taskId);
+}
+
+export async function appendMissed(record: CronMissedRecord): Promise<void> {
+  await appendMissedRecord(missedFile(), record);
+}
+
+export async function listMissed(limit = 20): Promise<CronMissedRecord[]> {
+  return await listMissedRecords(missedFile(), limit);
+}
+
+export async function markMissedRead(taskId?: string): Promise<void> {
+  await markMissedRecordsRead(missedFile(), taskId);
+}
+
+export function createTask(input: {
+  name: string;
+  description?: string;
+  cron?: string;
+  intervalMs?: number;
+  anchorAt?: string;
+  timezone: string;
+  cwd: string;
+  sessionId?: string;
+  model?: string;
+  maxTurns?: number;
+  kind?: CronTask['kind'];
+  permanent?: boolean;
+  expiresAt?: string;
+  maxRuns?: number;
+  sessionMode?: CronTask['runtime']['sessionMode'];
+  jitterMs?: number;
+  action: CronTask['action'];
+}): CronTask {
+  const now = new Date().toISOString();
+  const id = `cron-${randomUUID().slice(0, 8)}`;
+  if (!input.cron && !input.intervalMs) {
+    throw new Error('createTask requires cron or intervalMs');
+  }
+  const schedule = input.intervalMs
+    ? {
+        type: 'interval' as const,
+        intervalMs: input.intervalMs,
+        anchorAt: input.anchorAt ?? now,
+        human: intervalToHuman(input.intervalMs),
+        jitterMs: input.jitterMs ?? 0,
+      }
+    : {
+        type: 'cron' as const,
+        cron: input.cron!,
+        timezone: input.timezone,
+        human: cronToHuman(input.cron!),
+        jitterMs: input.jitterMs ?? 0,
+      };
+  return refreshNextRun({
+    id,
+    name: input.name,
+    ...(input.description ? { description: input.description } : {}),
+    status: 'active',
+    kind: input.kind ?? 'recurring',
+    ...(input.permanent ? { permanent: true } : {}),
+    ...(input.expiresAt ? { expiresAt: input.expiresAt } : {}),
+    ...(input.maxRuns ? { maxRuns: input.maxRuns } : {}),
+    schedule,
+    action: input.action,
+    runtime: {
+      cwd: input.cwd,
+      environment: 'project',
+      sessionId: input.sessionId ?? 'default',
+      sessionMode: input.sessionMode ?? 'persistent',
+      bindingStatus: (!input.sessionId || !input.sessionId.startsWith('cron-')) && input.sessionMode !== 'fresh'
+        ? 'bound'
+        : 'needs_binding',
+      ...(input.model ? { model: input.model } : {}),
+      ...(input.maxTurns ? { maxTurns: input.maxTurns } : {}),
+    },
+    stats: {
+      runCount: 0,
+      successCount: 0,
+      failureCount: 0,
+      skippedCount: 0,
+    },
+    createdAt: now,
+    updatedAt: now,
+  });
+}
+
+export function refreshNextRun(task: CronTask, fromMs = Date.now()): CronTask {
+  const expired =
+    task.expiresAt && !task.permanent && Date.parse(task.expiresAt) <= fromMs;
+  const next = task.status === 'active' && !expired
+    ? nextScheduleRunMs(task.schedule, fromMs)
+    : null;
+  return {
+    ...task,
+    ...(expired ? { status: 'completed' as const } : {}),
+    schedule: {
+      ...task.schedule,
+      human: task.schedule.type === 'cron'
+        ? cronToHuman(task.schedule.cron)
+        : intervalToHuman(task.schedule.intervalMs),
+      jitterMs: typeof task.schedule.jitterMs === 'number' ? task.schedule.jitterMs : 0,
+      ...(next ? { nextRunAt: new Date(next).toISOString() } : { nextRunAt: undefined }),
+    },
+  };
+}
+
+/** Update only user-editable fields while preserving scheduler cursors, stats and creation time. */
+export async function patchTask(patch: CronTaskPatch): Promise<CronTask | undefined> {
+  return await updateTask(patch.id, (current) => {
+    const nextSchedule = patch.schedule
+      ? patch.schedule.type === 'cron'
+        ? {
+            ...current.schedule,
+            type: 'cron' as const,
+            cron: patch.schedule.cron,
+            timezone: patch.schedule.timezone,
+            jitterMs: patch.schedule.jitterMs ?? 0,
+            human: cronToHuman(patch.schedule.cron),
+          }
+        : {
+            ...current.schedule,
+            type: 'interval' as const,
+            intervalMs: patch.schedule.intervalMs,
+            anchorAt: patch.schedule.anchorAt ?? new Date().toISOString(),
+            jitterMs: patch.schedule.jitterMs ?? 0,
+            human: intervalToHuman(patch.schedule.intervalMs),
+          }
+      : current.schedule;
+    const runtime = patch.runtime
+      ? {
+          ...current.runtime,
+          ...patch.runtime,
+          sessionMode: 'persistent' as const,
+          bindingStatus:
+            patch.runtime.sessionId && !patch.runtime.sessionId.startsWith('cron-')
+              ? 'bound' as const
+              : current.runtime.bindingStatus,
+        }
+      : current.runtime;
+    return {
+      ...current,
+      ...(patch.name !== undefined ? { name: patch.name.trim() } : {}),
+      ...(patch.description !== undefined
+        ? patch.description.trim() ? { description: patch.description.trim() } : { description: undefined }
+        : {}),
+      ...(patch.status !== undefined ? { status: patch.status } : {}),
+      ...(patch.kind !== undefined ? { kind: patch.kind } : {}),
+      ...(patch.permanent !== undefined ? { permanent: patch.permanent || undefined } : {}),
+      ...(patch.expiresAt !== undefined ? { expiresAt: patch.expiresAt || undefined } : {}),
+      ...(patch.maxRuns !== undefined ? { maxRuns: patch.maxRuns || undefined } : {}),
+      schedule: nextSchedule,
+      ...(patch.action ? { action: patch.action } : {}),
+      runtime,
+    };
+  });
+}

package/plugins/cron-runner/src/types.ts

@@ -0,0 +1,141 @@
+export type CronTaskStatus = 'active' | 'paused' | 'completed';
+export type CronTaskKind = 'recurring' | 'once';
+export type CronSessionMode = 'persistent' | 'fresh';
+export type CronBindingStatus = 'bound' | 'needs_binding';
+export type CronAttentionReason = 'failure' | 'offline' | 'overlap' | 'workspace_unavailable';
+
+interface CronScheduleState {
+  human: string;
+  nextRunAt?: string;
+  lastFiredAt?: string;
+  lastScheduledFor?: string;
+  jitterMs?: number;
+}
+
+export type CronSchedule =
+  | (CronScheduleState & {
+      type: 'cron';
+      cron: string;
+      timezone: string;
+    })
+  | (CronScheduleState & {
+      type: 'interval';
+      intervalMs: number;
+      anchorAt: string;
+    });
+
+export interface CronTask {
+  id: string;
+  name: string;
+  description?: string;
+  status: CronTaskStatus;
+  kind: CronTaskKind;
+  permanent?: boolean;
+  expiresAt?: string;
+  /** 执行次数上限：跑满这么多次后自动暂停（成功/失败都计入，与 kind==='once' 同语义，once=maxRuns:1 的特例）。
+   *  不设 = 不限次数（配合 expiresAt/permanent 控制终止）。 */
+  maxRuns?: number;
+  schedule: CronSchedule;
+  action:
+    | { type: 'prompt'; prompt: string }
+    | { type: 'workflow'; command: string };
+  runtime: {
+    cwd: string;
+    environment: 'project';
+    sessionId: string;
+    sessionMode: CronSessionMode;
+    bindingStatus: CronBindingStatus;
+    model?: string;
+    maxTurns?: number;
+  };
+  stats: {
+    runCount: number;
+    successCount: number;
+    failureCount: number;
+    skippedCount: number;
+    lastRunAt?: string;
+    lastSuccessAt?: string;
+    lastFailureAt?: string;
+  };
+  createdAt: string;
+  updatedAt: string;
+}
+
+/** Browser/remote input. Scheduler-owned cursors and stats are excluded. */
+export interface CronTaskDraft {
+  id?: string;
+  name: string;
+  description?: string;
+  status: CronTaskStatus;
+  kind: CronTaskKind;
+  permanent?: boolean;
+  expiresAt?: string;
+  maxRuns?: number;
+  schedule:
+    | { type: 'cron'; cron: string; timezone: string; jitterMs?: number }
+    | { type: 'interval'; intervalMs: number; anchorAt?: string; jitterMs?: number };
+  action: CronTask['action'];
+  runtime: {
+    cwd: string;
+    /** Bind the schedule to an existing workspace session. */
+    sessionId?: string;
+    sessionMode?: CronSessionMode;
+    model?: string;
+    maxTurns?: number;
+  };
+}
+
+export interface CronRunRecord {
+  id: string;
+  taskId: string;
+  taskName: string;
+  scheduledFor?: string;
+  startedAt: string;
+  finishedAt?: string;
+  status: 'running' | 'success' | 'failure';
+  cwd: string;
+  sessionId: string;
+  model?: string;
+  resultPreview?: string;
+  error?: string;
+  durationMs?: number;
+  readAt?: string;
+  attentionReason?: CronAttentionReason;
+}
+
+export interface CronMissedRecord {
+  id: string;
+  taskId: string;
+  taskName: string;
+  scheduledFor: string;
+  detectedAt: string;
+  actionPreview: string;
+  reason: 'offline' | 'overlap' | 'binding_unavailable';
+  missedCount: number;
+  readAt?: string;
+}
+
+export interface CronTaskPatch {
+  id: string;
+  name?: string;
+  description?: string;
+  status?: CronTaskStatus;
+  kind?: CronTaskKind;
+  permanent?: boolean;
+  expiresAt?: string;
+  maxRuns?: number;
+  schedule?: CronTaskDraft['schedule'];
+  action?: CronTask['action'];
+  runtime?: Partial<CronTaskDraft['runtime']>;
+}
+
+export interface CronListFilter {
+  query?: string;
+  status?: 'all' | 'active' | 'paused' | 'completed' | 'attention';
+  cwd?: string;
+  sessionId?: string;
+}
+
+export interface CronTaskFile {
+  tasks: CronTask[];
+}