openfox 2.0.141 → 2.0.142

package/dist/{chunk-TJOKDC34.js → chunk-CSUMZAYY.js}

@@ -1,6 +1,6 @@
 import {
   serverT
-} from "./chunk-JLHYB445.js";
+} from "./chunk-TIIWXMGE.js";
 import {
   deleteItemFromDir,
   getDefaultIds,
@@ -11,13 +11,13 @@ import {
 } from "./chunk-OSXPQSLW.js";
 import {
   parseDefaultModelSelection
-} from "./chunk-H7YL7PH3.js";
+} from "./chunk-J556QIRD.js";
 import {
   getProject
-} from "./chunk-DPFET73G.js";
+} from "./chunk-JYYBSODN.js";
 import {
   getDatabase
-} from "./chunk-JU757HVI.js";
+} from "./chunk-WOVWVB5J.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -365,14 +365,17 @@ async function resolveSlashLaunch(configDir, projectDir, prompt) {
 
 // src/server/db/tasks.ts
 import { randomBytes } from "crypto";
+function scheduleNextRun(schedule) {
+  return schedule.type === "once" ? schedule.runAt : schedule.nextRunAt;
+}
 function createTask(projectId, input) {
   const db = getDatabase();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const id = randomBytes(8).toString("hex");
   const position = db.prepare(`SELECT COALESCE(MAX(position), -1) + 1 AS pos FROM tasks WHERE project_id = ? AND status = 'todo'`).get(projectId);
   db.prepare(
-    `INSERT INTO tasks (id, project_id, prompt, attachments, status, run_state, position, version, agent_id, provider_id, model, created_at, updated_at)
-     VALUES (?, ?, ?, ?, 'todo', NULL, ?, 1, ?, ?, ?, ?, ?)`
+    `INSERT INTO tasks (id, project_id, prompt, attachments, status, run_state, position, version, agent_id, provider_id, model, schedule, next_run_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, 'todo', NULL, ?, 1, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     id,
     projectId,
@@ -382,6 +385,8 @@ function createTask(projectId, input) {
     input.agentId ?? null,
     input.providerId ?? null,
     input.model ?? null,
+    input.schedule ? JSON.stringify(input.schedule) : null,
+    input.schedule ? scheduleNextRun(input.schedule) : null,
     now,
     now
   );
@@ -423,6 +428,12 @@ function updateTask(id, patch) {
     sets.push("model = ?");
     values.push(patch.model);
   }
+  if (patch.schedule !== void 0) {
+    sets.push("schedule = ?");
+    values.push(patch.schedule ? JSON.stringify(patch.schedule) : null);
+    sets.push("next_run_at = ?");
+    values.push(patch.schedule ? scheduleNextRun(patch.schedule) : null);
+  }
   values.push(id);
   db.prepare(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`).run(...values);
   return getTask(id);
@@ -449,6 +460,28 @@ function deleteTask(id) {
   const db = getDatabase();
   db.prepare(`DELETE FROM tasks WHERE id = ?`).run(id);
 }
+function listDueScheduledTasks(nowIso) {
+  const db = getDatabase();
+  const rows = db.prepare(
+    `SELECT * FROM tasks WHERE status = 'todo' AND next_run_at IS NOT NULL AND next_run_at <= ? ORDER BY next_run_at ASC`
+  ).all(nowIso);
+  return rows.map(hydrateTask);
+}
+function setTaskSchedule(id, schedule, nextRunAt) {
+  const db = getDatabase();
+  db.prepare(`UPDATE tasks SET schedule = ?, next_run_at = ?, version = version + 1, updated_at = ? WHERE id = ?`).run(
+    JSON.stringify(schedule),
+    nextRunAt,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    id
+  );
+}
+function clearTaskSchedule(id) {
+  const db = getDatabase();
+  db.prepare(
+    `UPDATE tasks SET schedule = NULL, next_run_at = NULL, version = version + 1, updated_at = ? WHERE id = ?`
+  ).run((/* @__PURE__ */ new Date()).toISOString(), id);
+}
 function appendToBottom(id, status) {
   const db = getDatabase();
   const task = getTask(id);
@@ -460,7 +493,7 @@ function appendToBottom(id, status) {
     id
   );
 }
-function cloneTask(sourceId) {
+function cloneTask(sourceId, copySchedule = true) {
   const source = getTask(sourceId);
   if (!source) return null;
   return createTask(source.projectId, {
@@ -468,7 +501,8 @@ function cloneTask(sourceId) {
     attachments: source.attachments,
     ...source.agentId ? { agentId: source.agentId } : {},
     ...source.providerId ? { providerId: source.providerId } : {},
-    ...source.model ? { model: source.model } : {}
+    ...source.model ? { model: source.model } : {},
+    ...copySchedule && source.schedule ? { schedule: source.schedule } : {}
   });
 }
 function reorderTask(id, status, toIndex) {
@@ -612,6 +646,7 @@ function hydrateTask(row) {
   const sessionIds = links.map((l) => l.session_id);
   const activeLink = links.find((l) => Boolean(l.active));
   const runState = row.status === "in_progress" ? row.run_state : void 0;
+  const schedule = row.schedule ? safeParseSchedule(row.schedule) : void 0;
   const task = {
     id: row.id,
     projectId: row.project_id,
@@ -624,6 +659,7 @@ function hydrateTask(row) {
     ...row.agent_id ? { agentId: row.agent_id } : {},
     ...row.provider_id ? { providerId: row.provider_id } : {},
     ...row.model ? { model: row.model } : {},
+    ...schedule ? { schedule } : {},
     sessionIds,
     ...activeLink ? { activeSessionId: activeLink.session_id } : {},
     gateValues: getGateValues(row.id),
@@ -656,6 +692,104 @@ function safeParseAttachments(raw) {
     return [];
   }
 }
+function safeParseSchedule(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    if (parsed.type === "once" && typeof parsed.runAt === "string") return parsed;
+    if (parsed.type === "recurring" && typeof parsed.interval === "number" && typeof parsed.startAt === "string" && typeof parsed.nextRunAt === "string" && parsed.end && typeof parsed.end.kind === "string" && typeof parsed.occurrencesDone === "number") {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/server/tasks/recurrence.ts
+var MS_DAY = 864e5;
+function dayDiff(a, b) {
+  const ua = Date.UTC(a.getFullYear(), a.getMonth(), a.getDate());
+  const ub = Date.UTC(b.getFullYear(), b.getMonth(), b.getDate());
+  return Math.round((ub - ua) / MS_DAY);
+}
+function addDays(date, days) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days);
+}
+function mondayOf(date) {
+  return addDays(date, -((date.getDay() + 6) % 7));
+}
+function lastDayOfMonth(y, m0) {
+  return new Date(y, m0 + 1, 0).getDate();
+}
+function nextOccurrence(after, rule) {
+  const start = new Date(rule.startAt);
+  if (Number.isNaN(start.getTime()) || !Number.isFinite(after.getTime())) return null;
+  if (rule.end.kind === "count" && rule.occurrencesDone >= rule.end.count) return null;
+  const hour = start.getHours();
+  const minute = start.getMinutes();
+  const second = start.getSeconds();
+  const ms = start.getMilliseconds();
+  const atTime = (y, m0, d) => new Date(y, m0, d, hour, minute, second, ms);
+  let candidate = null;
+  if (after.getTime() < start.getTime()) {
+    candidate = new Date(start);
+  } else if (rule.freq === "day") {
+    const k = Math.floor(dayDiff(start, after) / rule.interval);
+    let c = addDays(start, k * rule.interval);
+    if (c.getTime() <= after.getTime()) c = addDays(c, rule.interval);
+    candidate = atTime(c.getFullYear(), c.getMonth(), c.getDate());
+  } else if (rule.freq === "week") {
+    const weekdays = rule.weekdays && rule.weekdays.length > 0 ? rule.weekdays : [start.getDay()];
+    const baseMonday = mondayOf(start);
+    const maxDays = (rule.interval + 1) * 7 + 7;
+    for (let i = 1; i <= maxDays; i++) {
+      const c = addDays(after, i);
+      if (!weekdays.includes(c.getDay())) continue;
+      const weekIndex = Math.floor(dayDiff(baseMonday, mondayOf(c)) / 7);
+      if (weekIndex >= 0 && weekIndex % rule.interval === 0) {
+        candidate = atTime(c.getFullYear(), c.getMonth(), c.getDate());
+        break;
+      }
+    }
+  } else if (rule.freq === "month") {
+    const baseAbs = start.getFullYear() * 12 + start.getMonth();
+    const day = rule.monthDay ?? start.getDate();
+    const startAbs = after.getFullYear() * 12 + after.getMonth();
+    const rem = ((startAbs - baseAbs) % rule.interval + rule.interval) % rule.interval;
+    let mAbs = startAbs + (rem === 0 ? 0 : rule.interval - rem);
+    for (let i = 0; i <= rule.interval + 1; i++) {
+      const y = Math.floor(mAbs / 12);
+      const m0 = mAbs % 12;
+      const c = atTime(y, m0, Math.min(day, lastDayOfMonth(y, m0)));
+      if (c.getTime() > after.getTime()) {
+        candidate = c;
+        break;
+      }
+      mAbs += rule.interval;
+    }
+  } else {
+    const baseY = start.getFullYear();
+    const m = (rule.yearMonth ?? start.getMonth() + 1) - 1;
+    const day = rule.monthDay ?? start.getDate();
+    const rem = ((after.getFullYear() - baseY) % rule.interval + rule.interval) % rule.interval;
+    let y = after.getFullYear() + (rem === 0 ? 0 : rule.interval - rem);
+    for (let i = 0; i <= rule.interval + 1; i++) {
+      const c = atTime(y, m, Math.min(day, lastDayOfMonth(y, m)));
+      if (c.getTime() > after.getTime()) {
+        candidate = c;
+        break;
+      }
+      y += rule.interval;
+    }
+  }
+  if (!candidate) return null;
+  if (rule.end.kind === "until") {
+    const until = new Date(rule.end.until);
+    if (Number.isNaN(until.getTime()) || candidate.getTime() > until.getTime()) return null;
+  }
+  return candidate;
+}
 
 // src/server/tasks/service.ts
 function isTaskConflictError(err) {
@@ -745,7 +879,8 @@ function createTasksService(deps) {
       attachments: input.attachments ?? [],
       ...input.agentId ? { agentId: input.agentId } : {},
       ...input.providerId ? { providerId: input.providerId } : {},
-      ...input.model ? { model: input.model } : {}
+      ...input.model ? { model: input.model } : {},
+      ...input.schedule ? { schedule: normalizeSchedule(input.schedule) } : {}
     });
     addAuditEntry(task.id, actor.actor, "create", `Task created in To Do`, actor.actorName);
     const fresh = getTask(task.id);
@@ -756,7 +891,10 @@ function createTasksService(deps) {
     return withLock(projectId, () => {
       const task = assertOwned(projectId, taskId);
       assertNotStale(task, expectedVersion);
-      const next = updateTask(taskId, patch) ?? getTask(taskId);
+      const next = updateTask(taskId, {
+        ...patch,
+        ...patch.schedule !== void 0 ? { schedule: patch.schedule === null ? null : normalizeSchedule(patch.schedule) } : {}
+      }) ?? getTask(taskId);
       const changed = summarizeChanges(task, next);
       addAuditEntry(taskId, actor.actor, "edit", changed || "Task updated", actor.actorName);
       const fresh = getTask(taskId);
@@ -792,87 +930,164 @@ function createTasksService(deps) {
     });
   }
   function move(projectId, taskId, to, opts) {
-    return withLock(projectId, async () => {
-      const task = assertOwned(projectId, taskId);
-      assertNotStale(task, opts.expectedVersion);
-      const from = task.status;
-      if (from === to) {
-        return { task };
+    return withLock(projectId, () => moveLocked(projectId, taskId, to, opts));
+  }
+  async function moveLocked(projectId, taskId, to, opts) {
+    const task = assertOwned(projectId, taskId);
+    assertNotStale(task, opts.expectedVersion);
+    const from = task.status;
+    if (from === to) {
+      return { task };
+    }
+    let sessionId;
+    const wasRunning = task.status === "in_progress" && task.runState === "running";
+    if (to === "in_progress") {
+      const readyGates = requiredGates(projectId, "ready");
+      const missing = missingGateFields(task, readyGates);
+      if (missing.length > 0) {
+        throw gateBlockedError(task, "In Progress", missing);
       }
-      let sessionId;
-      const wasRunning = task.status === "in_progress" && task.runState === "running";
-      if (to === "in_progress") {
-        const readyGates = requiredGates(projectId, "ready");
-        const missing = missingGateFields(task, readyGates);
-        if (missing.length > 0) {
-          throw gateBlockedError(task, "In Progress", missing);
+      setTaskStatus(taskId, "in_progress");
+      const settings = getTaskSettings(projectId);
+      if (opts.actor === "agent") {
+        if (!opts.sessionId) {
+          throw new Error(
+            serverT({
+              en: "Agent moves must bind to the current session (sessionId is required)",
+              fr: "Les d\xE9placements d\u2019agent doivent \xEAtre li\xE9s \xE0 la session courante (sessionId requis)"
+            })
+          );
         }
-        setTaskStatus(taskId, "in_progress");
-        const settings = getTaskSettings(projectId);
-        if (opts.actor === "agent") {
-          if (!opts.sessionId) {
-            throw new Error(
-              serverT({
-                en: "Agent moves must bind to the current session (sessionId is required)",
-                fr: "Les d\xE9placements d\u2019agent doivent \xEAtre li\xE9s \xE0 la session courante (sessionId requis)"
-              })
+        setTaskRunState(taskId, "running");
+        addTaskLink(taskId, opts.sessionId, true);
+        addAuditEntry(taskId, "agent", "move", `Moved to In Progress (running)`, opts.actorName);
+        emitReminder(opts.sessionId, reminderForInProgress(task, opts.sessionId, from));
+        sessionId = opts.sessionId;
+      } else {
+        const runningCount = activeCount(projectId);
+        const launched = runningCount < settings.slotLimit && !settings.queuePaused;
+        setTaskRunState(taskId, launched ? "running" : "queued");
+        if (task.schedule) {
+          clearTaskSchedule(taskId);
+        }
+        if (launched) {
+          const seeded = await seedSession(projectId, task, from, reusableTarget(projectId, opts.sessionId));
+          addTaskLink(taskId, seeded.session.id, true);
+          addAuditEntry(taskId, opts.actor, "move", `Moved to In Progress (running)`, opts.actorName);
+          sessionId = seeded.session.id;
+        } else {
+          appendToBottom(taskId, "in_progress");
+          const earmarked = reusableTarget(projectId, opts.sessionId);
+          if (earmarked) addTaskLink(taskId, earmarked, false);
+          addAuditEntry(taskId, opts.actor, "move", `Moved to In Progress (queued)`, opts.actorName);
+        }
+      }
+    } else if (to === "done") {
+      const doneGates = requiredGates(projectId, "done");
+      const missing = missingGateFields(task, doneGates);
+      if (missing.length > 0) {
+        throw gateBlockedError(task, "Done", missing);
+      }
+      setTaskStatus(taskId, "done");
+      clearActiveTaskLink(taskId);
+      if (task.schedule) clearTaskSchedule(taskId);
+      addAuditEntry(taskId, opts.actor, "move", `Moved to Done`, opts.actorName);
+      if (task.activeSessionId) {
+        emitReminder(task.activeSessionId, reminderForDone(task));
+      }
+    } else {
+      setTaskStatus(taskId, "todo");
+      removeTaskLinks(taskId);
+      const detailParts = [`Moved back to To Do`];
+      if (opts.reason) detailParts.push(`Reason: ${opts.reason}`);
+      addAuditEntry(taskId, opts.actor, "move", detailParts.join(". "), opts.actorName);
+      if (task.activeSessionId) {
+        emitReminder(task.activeSessionId, reminderForTodo(task));
+      }
+    }
+    const fresh = getTask(taskId);
+    let autoLaunched;
+    if (wasRunning || to === "todo" && from === "in_progress") {
+      autoLaunched = await maybeAutoLaunch(projectId);
+    }
+    publish(projectId, fresh.id, autoLaunched);
+    return {
+      task: fresh,
+      ...sessionId ? { sessionId } : {},
+      ...autoLaunched ? { autoLaunched } : {}
+    };
+  }
+  async function runScheduled(now = /* @__PURE__ */ new Date()) {
+    const due = listDueScheduledTasks(now.toISOString());
+    for (const task of due) {
+      try {
+        await withLock(task.projectId, async () => {
+          const fresh = getTask(task.id);
+          if (!fresh || fresh.status !== "todo" || !fresh.schedule) return;
+          const schedule = fresh.schedule;
+          if (schedule.type === "once") {
+            await moveLocked(fresh.projectId, fresh.id, "in_progress", { actor: "system" });
+            return;
+          }
+          const readyGates = requiredGates(fresh.projectId, "ready");
+          if (missingGateFields(fresh, readyGates).length > 0) {
+            logger.warn("Scheduled recurring spawn skipped: missing ready gates", {
+              taskId: fresh.id,
+              gates: readyGates.map((g) => g.name).join(", ")
+            });
+            return;
+          }
+          const run = cloneTask(fresh.id, false);
+          if (run) {
+            try {
+              await moveLocked(run.projectId, run.id, "in_progress", { actor: "system" });
+            } catch (error) {
+              deleteTask(run.id);
+              throw error;
+            }
+            addAuditEntry(
+              run.id,
+              "system",
+              "scheduled_run",
+              `Spawned from recurring task "${promptLabel(fresh.prompt)}"`,
+              "system"
             );
           }
-          setTaskRunState(taskId, "running");
-          addTaskLink(taskId, opts.sessionId, true);
-          addAuditEntry(taskId, "agent", "move", `Moved to In Progress (running)`, opts.actorName);
-          emitReminder(opts.sessionId, reminderForInProgress(task, opts.sessionId, from));
-          sessionId = opts.sessionId;
-        } else {
-          const runningCount = activeCount(projectId);
-          const launched = runningCount < settings.slotLimit && !settings.queuePaused;
-          setTaskRunState(taskId, launched ? "running" : "queued");
-          if (launched) {
-            const seeded = await seedSession(projectId, task, from, reusableTarget(projectId, opts.sessionId));
-            addTaskLink(taskId, seeded.session.id, true);
-            addAuditEntry(taskId, "human", "move", `Moved to In Progress (running)`, opts.actorName);
-            sessionId = seeded.session.id;
+          const rule = {
+            freq: schedule.freq,
+            interval: schedule.interval,
+            ...schedule.weekdays ? { weekdays: schedule.weekdays } : {},
+            ...schedule.monthDay ? { monthDay: schedule.monthDay } : {},
+            ...schedule.yearMonth ? { yearMonth: schedule.yearMonth } : {},
+            startAt: schedule.startAt,
+            end: schedule.end,
+            occurrencesDone: schedule.occurrencesDone + 1
+          };
+          const next = nextOccurrence(now, rule);
+          if (next) {
+            const advanced = {
+              ...schedule,
+              occurrencesDone: schedule.occurrencesDone + 1,
+              nextRunAt: next.toISOString()
+            };
+            setTaskSchedule(fresh.id, advanced, next.toISOString());
+            addAuditEntry(
+              fresh.id,
+              "system",
+              "scheduled_run",
+              `Triggered occurrence ${schedule.occurrencesDone + 1}, next run ${next.toISOString()}`,
+              "system"
+            );
           } else {
-            appendToBottom(taskId, "in_progress");
-            const earmarked = reusableTarget(projectId, opts.sessionId);
-            if (earmarked) addTaskLink(taskId, earmarked, false);
-            addAuditEntry(taskId, "human", "move", `Moved to In Progress (queued)`, opts.actorName);
+            clearTaskSchedule(fresh.id);
+            addAuditEntry(fresh.id, "system", "schedule_ended", "Recurrence ended \u2014 schedule cleared", "system");
           }
-        }
-      } else if (to === "done") {
-        const doneGates = requiredGates(projectId, "done");
-        const missing = missingGateFields(task, doneGates);
-        if (missing.length > 0) {
-          throw gateBlockedError(task, "Done", missing);
-        }
-        setTaskStatus(taskId, "done");
-        clearActiveTaskLink(taskId);
-        addAuditEntry(taskId, opts.actor, "move", `Moved to Done`, opts.actorName);
-        if (task.activeSessionId) {
-          emitReminder(task.activeSessionId, reminderForDone(task));
-        }
-      } else {
-        setTaskStatus(taskId, "todo");
-        removeTaskLinks(taskId);
-        const detailParts = [`Moved back to To Do`];
-        if (opts.reason) detailParts.push(`Reason: ${opts.reason}`);
-        addAuditEntry(taskId, opts.actor, "move", detailParts.join(". "), opts.actorName);
-        if (task.activeSessionId) {
-          emitReminder(task.activeSessionId, reminderForTodo(task));
-        }
-      }
-      const fresh = getTask(taskId);
-      let autoLaunched;
-      if (wasRunning || to === "todo" && from === "in_progress") {
-        autoLaunched = await maybeAutoLaunch(projectId);
+          publish(fresh.projectId, fresh.id);
+        });
+      } catch (error) {
+        logger.warn("Scheduled task trigger failed", { taskId: task.id, error: String(error) });
       }
-      publish(projectId, fresh.id, autoLaunched);
-      return {
-        task: fresh,
-        ...sessionId ? { sessionId } : {},
-        ...autoLaunched ? { autoLaunched } : {}
-      };
-    });
+    }
   }
   function setGateValue2(projectId, taskId, gateId, value, actor, sessionId, expectedVersion) {
     return withLock(projectId, () => {
@@ -1106,7 +1321,105 @@ ${evidenceLine}`,
     setGateConfig,
     setSettings,
     reorder,
-    counts
+    counts,
+    runScheduled
+  };
+}
+function normalizeSchedule(input) {
+  if (input.type === "once") {
+    if (!Number.isFinite(new Date(input.runAt).getTime())) {
+      throw new Error(
+        serverT(
+          { en: "Invalid schedule time: {{time}}", fr: "Heure de planification invalide : {{time}}" },
+          {
+            time: input.runAt
+          }
+        )
+      );
+    }
+    return { type: "once", runAt: input.runAt };
+  }
+  const { freq, interval, startAt, end } = input;
+  if (!Number.isInteger(interval) || interval < 1) {
+    throw new Error(
+      serverT({
+        en: "Recurring interval must be a positive integer",
+        fr: "L\u2019intervalle de r\xE9currence doit \xEAtre un entier positif"
+      })
+    );
+  }
+  if (freq === "week") {
+    const days = input.weekdays ?? [];
+    if (days.length === 0 || !days.every((d) => Number.isInteger(d) && d >= 0 && d <= 6)) {
+      throw new Error(
+        serverT({
+          en: "Weekly recurrence requires at least one selected weekday",
+          fr: "La r\xE9currence hebdomadaire requiert au moins un jour de la semaine s\xE9lectionn\xE9"
+        })
+      );
+    }
+  }
+  if ((freq === "month" || freq === "year") && input.monthDay !== void 0) {
+    if (!Number.isInteger(input.monthDay) || input.monthDay < 1 || input.monthDay > 31) {
+      throw new Error(
+        serverT({
+          en: "Day of month must be between 1 and 31",
+          fr: "Le jour du mois doit \xEAtre compris entre 1 et 31"
+        })
+      );
+    }
+  }
+  if (freq === "year" && input.yearMonth !== void 0) {
+    if (!Number.isInteger(input.yearMonth) || input.yearMonth < 1 || input.yearMonth > 12) {
+      throw new Error(
+        serverT({
+          en: "Month must be between 1 and 12",
+          fr: "Le mois doit \xEAtre compris entre 1 et 12"
+        })
+      );
+    }
+  }
+  if (!Number.isFinite(new Date(startAt).getTime())) {
+    throw new Error(
+      serverT(
+        {
+          en: "Invalid schedule start time: {{time}}",
+          fr: "Heure de d\xE9part de planification invalide : {{time}}"
+        },
+        { time: startAt }
+      )
+    );
+  }
+  if (end.kind === "until" && !Number.isFinite(new Date(end.until).getTime())) {
+    throw new Error(
+      serverT(
+        {
+          en: "Invalid recurrence end date: {{time}}",
+          fr: "Date de fin de r\xE9currence invalide : {{time}}"
+        },
+        { time: end.until }
+      )
+    );
+  }
+  if (end.kind === "count" && (!Number.isInteger(end.count) || end.count < 1)) {
+    throw new Error(
+      serverT({
+        en: "Occurrence count must be a positive integer",
+        fr: "Le nombre d\u2019occurrences doit \xEAtre un entier positif"
+      })
+    );
+  }
+  return {
+    type: "recurring",
+    freq,
+    interval,
+    ...input.weekdays ? { weekdays: input.weekdays } : {},
+    ...input.monthDay !== void 0 ? { monthDay: input.monthDay } : {},
+    ...input.yearMonth !== void 0 ? { yearMonth: input.yearMonth } : {},
+    startAt,
+    end,
+    occurrencesDone: 0,
+    nextRunAt: startAt
   };
 }
 function promptLabel(prompt) {
@@ -1149,4 +1462,4 @@ export {
   isTaskGateError,
   createTasksService
 };
-//# sourceMappingURL=chunk-TJOKDC34.js.map
+//# sourceMappingURL=chunk-CSUMZAYY.js.map

package/dist/{chunk-EE6VFEE6.js → chunk-DNL2NUDB.js}

@@ -1,7 +1,7 @@
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-EMXMTCSY.js";
+} from "./chunk-SKNPOZYP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -194,4 +194,4 @@ export {
   ChatHttpClient,
   OpenAIHttpClient
 };
-//# sourceMappingURL=chunk-EE6VFEE6.js.map
+//# sourceMappingURL=chunk-DNL2NUDB.js.map

package/dist/{chunk-UA2ATO3B.js → chunk-DQEANXXF.js}

@@ -11,11 +11,11 @@ import {
 } from "./chunk-I72ACQ6R.js";
 import {
   getPlatformShell
-} from "./chunk-46Q2SHGJ.js";
+} from "./chunk-MEPTCUYN.js";
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-EMXMTCSY.js";
+} from "./chunk-SKNPOZYP.js";
 
 // src/server/utils/shell.ts
 import { spawn } from "child_process";
@@ -214,4 +214,4 @@ export {
   getSessionProcesses2 as getSessionProcesses,
   getProcessLogs
 };
-//# sourceMappingURL=chunk-UA2ATO3B.js.map
+//# sourceMappingURL=chunk-DQEANXXF.js.map

package/dist/{chunk-4F4ARGAM.js → chunk-DRIR2IZR.js}

@@ -3,11 +3,11 @@ import {
 } from "./chunk-OSXPQSLW.js";
 import {
   getProjectDefaultAgent
-} from "./chunk-DPFET73G.js";
+} from "./chunk-JYYBSODN.js";
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-EMXMTCSY.js";
+} from "./chunk-SKNPOZYP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -352,4 +352,4 @@ export {
   getOverrideAgentIds,
   resolveDefaultAgentId
 };
-//# sourceMappingURL=chunk-4F4ARGAM.js.map
+//# sourceMappingURL=chunk-DRIR2IZR.js.map

package/dist/{chunk-AE2IBEUH.js → chunk-EFEHIJXF.js}

@@ -1,6 +1,6 @@
 import {
   resolveDefaultAgentId
-} from "./chunk-4F4ARGAM.js";
+} from "./chunk-DRIR2IZR.js";
 import {
   normalizeAskOptions
 } from "./chunk-LCLH6ZUL.js";
@@ -983,4 +983,4 @@ export {
   buildSnapshot,
   buildSnapshotFromSessionState
 };
-//# sourceMappingURL=chunk-AE2IBEUH.js.map
+//# sourceMappingURL=chunk-EFEHIJXF.js.map

package/dist/chunk-EPZO3MGM.js

@@ -0,0 +1,7 @@
+// src/constants.ts
+var VERSION = "2.0.142";
+
+export {
+  VERSION
+};
+//# sourceMappingURL=chunk-EPZO3MGM.js.map