botnote 0.1.28 → 0.1.30

package/dist/service/projects.js.map

@@ -1 +1 @@
-{"version":3,"file":"projects.js","sourceRoot":"","sources":["../../src/service/projects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEjC,OAAO,EAAE,QAAQ,EAAgB,MAAM,iBAAiB,CAAC;AAGzD,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,EAAkB,EAClB,KAAyB;IAEzB,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,EAAE;SACnB,MAAM,CAAC,QAAQ,CAAC;SAChB,MAAM,CAAC;QACN,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ;KACzB,CAAC;SACD,SAAS,EAAE,CAAC;IACf,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IAC5D,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,EAAkB,EAClB,EAAU,EACV,KAAyB;IAEzB,MAAM,GAAG,GAA4B,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC;IACzE,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;IACxF,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;IACrD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,EAAkB,EAClB,GAAW;IAEX,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACpF,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AACzB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,EAAkB,EAAE,EAAU;IAC7D,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClF,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AACzB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,EAAkB;IACnD,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AAC1D,CAAC"}
+{"version":3,"file":"projects.js","sourceRoot":"","sources":["../../src/service/projects.ts"],"names":[],"mappings":"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"}

package/dist/service/recurrence.d.ts

@@ -1,13 +1,51 @@
+import rrulePkg from "rrule";
 import type { Database } from "../db/client.js";
 import { type Entity, type RecurrenceRule } from "../db/schema.js";
-import type { RecurrenceInput, StopRecurrenceInput, UpdateRecurrenceInput } from "./types.js";
+import type { RecurrenceInput, SplitRecurrenceInput, StopRecurrenceInput, UpdateRecurrenceInput } from "./types.js";
+type BaselineFields = {
+    title?: string | null;
+    body?: string;
+    tags?: string[];
+    priority?: string;
+};
+export type ContentFieldKey = "title" | "body" | "tags" | "priority";
+interface RecurrenceMarker {
+    ruleId: string;
+    seriesId: string;
+    role: "occurrence";
+    occurrenceAt: string;
+    occurrenceIndex: number;
+}
 export interface RecurrenceDetails {
     rule: RecurrenceRule;
     currentOccurrence: Entity | null;
 }
+export declare function recurrenceMarker(e: Entity): Partial<RecurrenceMarker> | null;
+export declare function buildRRule(rule: Pick<RecurrenceRule, "rrule" | "dtstart">, dtstart?: Date): rrulePkg.RRule;
+/**
+ * Normalize a computed occurrence date for storage.
+ * - All-day rules: resolve the calendar day as seen in the rule's timezone,
+ *   then snap to noon UTC (so the intended local calendar day is preserved
+ *   across all UTC-offset clients).
+ * - Timed rules: use normalizeDueAt (exact-midnight-UTC -> noon-UTC heuristic).
+ */
+export declare function normalizeOccurrenceDueAt(rule: Pick<RecurrenceRule, "allDay" | "timezone">, date: Date): Date;
+export declare function findRuleForTask(db: Database["db"], task: Entity, includeDisabled?: boolean): Promise<RecurrenceRule | null>;
 export declare function getRecurrenceForTask(db: Database["db"], taskId: string): Promise<RecurrenceDetails | null>;
 export declare function createRecurrenceRule(db: Database["db"], taskId: string, input: RecurrenceInput): Promise<RecurrenceRule>;
 export declare function updateRecurrenceRule(db: Database["db"], ruleId: string, input: UpdateRecurrenceInput): Promise<RecurrenceRule>;
+/**
+ * Upsert a 'modified' exception row recording the pre-edit (baseline) values
+ * of content fields for this occurrence. Uses earliest-wins merge: only
+ * adds a field to baseline if not already present.
+ */
+export declare function upsertModifiedExceptionBaseline(db: Database["db"], rule: RecurrenceRule, occurrence: Entity, preEditValues: BaselineFields, changedFields: ContentFieldKey[]): Promise<void>;
+/**
+ * Remove the given fields from an existing 'modified' exception's baseline.
+ * If baseline becomes empty after removal, delete the row.
+ */
+export declare function clearModifiedExceptionFields(db: Database["db"], _rule: RecurrenceRule, occurrence: Entity, changedFields: ContentFieldKey[]): Promise<void>;
+export declare function materializeScheduledRecurrences(db: Database["db"], upTo: Date, limit?: number): Promise<Entity[]>;
 export declare function advanceRecurrenceOnCompletion(db: Database["db"], occurrence: Entity, completedAt?: Date): Promise<Entity | null>;
 export declare function skipOccurrence(db: Database["db"], taskId: string, input?: {
     reason?: string;
@@ -18,3 +56,28 @@ export declare function skipOccurrence(db: Database["db"], taskId: string, input
     rule: RecurrenceRule;
 }>;
 export declare function stopRecurrence(db: Database["db"], ruleId: string, _input?: StopRecurrenceInput): Promise<RecurrenceRule>;
+/**
+ * Fork a recurrence series at its current occurrence: freeze the old rule and
+ * apply a new cadence going forward, keeping the same series so the UI still
+ * shows one continuous timeline (history + future).
+ *
+ * Mechanics:
+ *  - The old rule is bounded with UNTIL at the fork point and disabled. It stays
+ *    as frozen history (its already-materialized occurrences are untouched).
+ *  - A new enabled rule is created sharing the SAME series_id (UI continuity)
+ *    with the new RRULE. The live occurrence is kept as its template/display
+ *    source.
+ *  - The new rule has a distinct id, so its occurrences live in a disjoint
+ *    idempotency-key space (`recurrence:<ruleId>:<dueAt>`): no duplicate or
+ *    orphan occurrence can appear at the fork even if a date coincides.
+ *  - Scheduled forks let the materializer grow the new rule from the first
+ *    occurrence after the fork; the live occurrence stays on the old rule as the
+ *    tail of history. Completion forks re-home the live occurrence onto the new
+ *    rule so completing it advances the new cadence.
+ *
+ * The whole operation runs in one transaction: the old rule is disabled before
+ * the new one is inserted, so the partial-unique "one enabled rule per series"
+ * index holds at every step.
+ */
+export declare function splitRecurrence(db: Database["db"], ruleId: string, input: SplitRecurrenceInput): Promise<RecurrenceRule>;
+export {};

package/dist/service/recurrence.js

@@ -1,7 +1,8 @@
-import { and, eq, or } from "drizzle-orm";
+import { and, asc, desc, eq, lte, or } from "drizzle-orm";
 import rrulePkg from "rrule";
 import { entities, recurrenceExceptions, recurrenceRules } from "../db/schema.js";
-import { normalizeDueAt } from "./dates.js";
+import { allDayDueAtInZone, normalizeDueAt } from "./dates.js";
+import { getWorkspaceSettings } from "./workspace_settings.js";
 const { RRule } = rrulePkg;
 const WEEKDAYS = {
     MO: RRule.MO,
@@ -24,7 +25,7 @@ function metadataObject(value) {
         return {};
     return { ...value };
 }
-function recurrenceMarker(e) {
+export function recurrenceMarker(e) {
     const metadata = metadataObject(e.metadata);
     if (!metadata.recurrence || typeof metadata.recurrence !== "object")
         return null;
@@ -80,13 +81,36 @@ function buildRRuleFromInput(input, dtstart) {
         options.count = input.count;
     return rruleLine(new RRule(options));
 }
-function buildRRule(rule, dtstart = rule.dtstart) {
+export function buildRRule(rule, dtstart = rule.dtstart) {
     const parsed = RRule.parseString(rule.rrule);
     return new RRule({ ...parsed, dtstart });
 }
+/**
+ * Bound an existing RRULE with UNTIL at the fork point (used when freezing the
+ * old rule during a split). UNTIL supersedes any COUNT the rule carried.
+ */
+function applyUntilToRrule(rruleText, dtstart, until) {
+    const parsed = RRule.parseString(rruleText);
+    delete parsed.count;
+    parsed.until = until;
+    return rruleLine(new RRule({ ...parsed, dtstart }));
+}
 function maxDate(a, b) {
     return a.getTime() >= b.getTime() ? a : b;
 }
+/**
+ * Normalize a computed occurrence date for storage.
+ * - All-day rules: resolve the calendar day as seen in the rule's timezone,
+ *   then snap to noon UTC (so the intended local calendar day is preserved
+ *   across all UTC-offset clients).
+ * - Timed rules: use normalizeDueAt (exact-midnight-UTC -> noon-UTC heuristic).
+ */
+export function normalizeOccurrenceDueAt(rule, date) {
+    if (rule.allDay) {
+        return allDayDueAtInZone(date, rule.timezone) ?? normalizeDueAt(date) ?? date;
+    }
+    return normalizeDueAt(date) ?? date;
+}
 function countLimit(rule) {
     return buildRRule(rule).options.count ?? null;
 }
@@ -100,7 +124,11 @@ function computeNextOccurrenceAt(rule, occurrence, completedAt) {
     const scheduledBase = occurrence.dueAt ?? rule.dtstart;
     const cursor = anchor === "completion" ? completedAt : maxDate(scheduledBase, completedAt);
     const next = rrule.after(cursor, false);
-    return next ? normalizeDueAt(next) : null;
+    return next ? normalizeOccurrenceDueAt(rule, next) : null;
+}
+function computeNextScheduledAfter(rule, after) {
+    const next = buildRRule(rule, rule.dtstart).after(after, false);
+    return next ? normalizeOccurrenceDueAt(rule, next) : null;
 }
 async function fetchEntity(db, id) {
     const rows = await db.select().from(entities).where(eq(entities.id, id)).limit(1);
@@ -109,13 +137,21 @@ async function fetchEntity(db, id) {
         throw new Error(`entity ${id} not found`);
     return row;
 }
-async function findRuleForTask(db, task, includeDisabled = true) {
+export async function findRuleForTask(db, task, includeDisabled = true) {
     const marker = recurrenceMarker(task);
     const cond = marker?.ruleId
         ? eq(recurrenceRules.id, marker.ruleId)
         : or(eq(recurrenceRules.currentOccurrenceId, task.id), eq(recurrenceRules.seriesId, task.id));
     const where = includeDisabled ? cond : and(cond, eq(recurrenceRules.enabled, true));
-    const rows = await db.select().from(recurrenceRules).where(where).limit(1);
+    // A split leaves multiple rules per series (disabled history + one active),
+    // so the seriesId/currentOccurrenceId fallback can match more than one. Prefer
+    // the active rule, then the most recent. (The marker.ruleId branch is exact.)
+    const rows = await db
+        .select()
+        .from(recurrenceRules)
+        .where(where)
+        .orderBy(desc(recurrenceRules.enabled), desc(recurrenceRules.createdAt))
+        .limit(1);
     return rows[0] ?? null;
 }
 export async function getRecurrenceForTask(db, taskId) {
@@ -137,11 +173,18 @@ export async function createRecurrenceRule(db, taskId, input) {
     if (task.status === "done" || task.status === "rejected") {
         throw new Error("recurrence cannot be attached to a terminal task");
     }
+    // Resolve timezone: explicit input wins; otherwise fall back to workspace tz.
+    const timezone = input.timezone ?? (await getWorkspaceSettings(db)).timezone;
     const existingRule = await findRuleForTask(db, task);
     const seriesId = existingRule?.seriesId ?? recurrenceMarker(task)?.seriesId ?? task.id;
     const dtstart = input.dtstart ? normalizeDueAt(input.dtstart) : task.dueAt;
     const rrule = buildRRuleFromInput(input, dtstart);
-    const nextOccurrenceAt = buildRRule({ rrule, dtstart }).after(dtstart, false);
+    const nextOccurrenceRaw = buildRRule({ rrule, dtstart }).after(dtstart, false);
+    // Build a partial rule shape for normalizeOccurrenceDueAt before the DB row exists.
+    const ruleShape = { allDay: input.allDay ?? true, timezone };
+    const nextOccurrenceAt = nextOccurrenceRaw
+        ? normalizeOccurrenceDueAt(ruleShape, nextOccurrenceRaw)
+        : null;
     let rule;
     if (existingRule) {
         const [updated] = await db
@@ -151,11 +194,11 @@ export async function createRecurrenceRule(db, taskId, input) {
             enabled: true,
             rrule,
             dtstart,
-            timezone: input.timezone,
+            timezone,
             allDay: input.allDay,
             anchor: input.anchor,
             maxInstancesAhead: 1,
-            nextOccurrenceAt: nextOccurrenceAt ? normalizeDueAt(nextOccurrenceAt) : null,
+            nextOccurrenceAt,
             endedAt: null
         })
             .where(eq(recurrenceRules.id, existingRule.id))
@@ -173,13 +216,13 @@ export async function createRecurrenceRule(db, taskId, input) {
             enabled: true,
             rrule,
             dtstart,
-            timezone: input.timezone,
+            timezone,
             allDay: input.allDay,
             anchor: input.anchor,
             maxInstancesAhead: 1,
             generatedCount: 1,
             lastOccurrenceAt: null,
-            nextOccurrenceAt: nextOccurrenceAt ? normalizeDueAt(nextOccurrenceAt) : null,
+            nextOccurrenceAt,
             endedAt: null
         })
             .returning();
@@ -228,17 +271,23 @@ export async function updateRecurrenceRule(db, ruleId, input) {
         anchor: input.anchor ?? (current.anchor === "completion" ? "completion" : "scheduled")
     };
     const rrule = input.rrule || input.preset ? buildRRuleFromInput(nextRRuleInput, dtstart) : current.rrule;
-    const nextOccurrenceAt = buildRRule({ rrule, dtstart }).after(dtstart, false);
+    const nextOccurrenceRaw = buildRRule({ rrule, dtstart }).after(dtstart, false);
+    const resolvedAllDay = input.allDay ?? current.allDay;
+    const resolvedTimezone = input.timezone ?? current.timezone;
+    const ruleShape = { allDay: resolvedAllDay, timezone: resolvedTimezone };
+    const nextOccurrenceAt = nextOccurrenceRaw
+        ? normalizeOccurrenceDueAt(ruleShape, nextOccurrenceRaw)
+        : null;
     const [updated] = await db
         .update(recurrenceRules)
         .set({
         enabled: input.enabled ?? current.enabled,
         rrule,
         dtstart,
-        timezone: input.timezone ?? current.timezone,
-        allDay: input.allDay ?? current.allDay,
+        timezone: resolvedTimezone,
+        allDay: resolvedAllDay,
         anchor: input.anchor ?? current.anchor,
-        nextOccurrenceAt: nextOccurrenceAt ? normalizeDueAt(nextOccurrenceAt) : null,
+        nextOccurrenceAt,
         endedAt: input.enabled === true ? null : current.endedAt
     })
         .where(eq(recurrenceRules.id, ruleId))
@@ -247,7 +296,135 @@ export async function updateRecurrenceRule(db, ruleId, input) {
         throw new Error(`recurrence rule ${ruleId} not found`);
     return updated;
 }
-async function insertNextOccurrence(db, rule, occurrence, nextDueAt) {
+// ---------------------------------------------------------------------------
+// Modified-exception helpers (scope='this' baseline management)
+// ---------------------------------------------------------------------------
+/**
+ * Find the existing 'modified' exception row for a given entity.
+ * Keyed by entityId (stable), not occurrenceAt.
+ */
+async function findModifiedExceptionForEntity(db, entityId) {
+    const rows = await db
+        .select({ id: recurrenceExceptions.id, metadata: recurrenceExceptions.metadata })
+        .from(recurrenceExceptions)
+        .where(and(eq(recurrenceExceptions.entityId, entityId), eq(recurrenceExceptions.action, "modified")))
+        .limit(1);
+    if (!rows[0])
+        return null;
+    const meta = rows[0].metadata;
+    return {
+        id: rows[0].id,
+        metadata: (meta && typeof meta === "object" && !Array.isArray(meta))
+            ? meta
+            : {}
+    };
+}
+/**
+ * Upsert a 'modified' exception row recording the pre-edit (baseline) values
+ * of content fields for this occurrence. Uses earliest-wins merge: only
+ * adds a field to baseline if not already present.
+ */
+export async function upsertModifiedExceptionBaseline(db, rule, occurrence, preEditValues, changedFields) {
+    const existing = await findModifiedExceptionForEntity(db, occurrence.id);
+    if (existing) {
+        const existingMeta = existing.metadata;
+        const existingBaseline = (existingMeta.baseline && typeof existingMeta.baseline === "object" && !Array.isArray(existingMeta.baseline)
+            ? existingMeta.baseline
+            : {});
+        const existingChangedFields = Array.isArray(existingMeta.changedFields)
+            ? existingMeta.changedFields
+            : [];
+        // Merge: only add fields not already in baseline (earliest value wins)
+        const mergedBaseline = { ...existingBaseline };
+        const mergedChangedFields = new Set(existingChangedFields);
+        for (const field of changedFields) {
+            if (!(field in mergedBaseline)) {
+                mergedBaseline[field] = preEditValues[field] ?? null;
+            }
+            mergedChangedFields.add(field);
+        }
+        await db
+            .update(recurrenceExceptions)
+            .set({
+            metadata: {
+                scope: "this",
+                baseline: mergedBaseline,
+                changedFields: Array.from(mergedChangedFields),
+                actorKind: "human"
+            }
+        })
+            .where(eq(recurrenceExceptions.id, existing.id));
+    }
+    else {
+        const baseline = {};
+        for (const field of changedFields) {
+            baseline[field] = preEditValues[field] ?? null;
+        }
+        await db.insert(recurrenceExceptions).values({
+            ruleId: rule.id,
+            occurrenceAt: occurrence.dueAt ?? rule.dtstart,
+            action: "modified",
+            entityId: occurrence.id,
+            metadata: {
+                scope: "this",
+                baseline,
+                changedFields,
+                actorKind: "human"
+            }
+        });
+    }
+}
+/**
+ * Remove the given fields from an existing 'modified' exception's baseline.
+ * If baseline becomes empty after removal, delete the row.
+ */
+export async function clearModifiedExceptionFields(db, _rule, occurrence, changedFields) {
+    const existing = await findModifiedExceptionForEntity(db, occurrence.id);
+    if (!existing)
+        return;
+    const existingMeta = existing.metadata;
+    const existingBaseline = (existingMeta.baseline && typeof existingMeta.baseline === "object" && !Array.isArray(existingMeta.baseline)
+        ? existingMeta.baseline
+        : {});
+    const existingChangedFields = Array.isArray(existingMeta.changedFields)
+        ? existingMeta.changedFields
+        : [];
+    const newBaseline = { ...existingBaseline };
+    const newChangedFields = existingChangedFields.filter((f) => !changedFields.includes(f));
+    for (const field of changedFields) {
+        delete newBaseline[field];
+    }
+    if (Object.keys(newBaseline).length === 0) {
+        await db.delete(recurrenceExceptions).where(eq(recurrenceExceptions.id, existing.id));
+    }
+    else {
+        await db
+            .update(recurrenceExceptions)
+            .set({
+            metadata: {
+                ...existingMeta,
+                baseline: newBaseline,
+                changedFields: newChangedFields
+            }
+        })
+            .where(eq(recurrenceExceptions.id, existing.id));
+    }
+}
+/**
+ * Fetch the baseline stored in the 'modified' exception for the given template
+ * occurrence. Returns null if no such exception exists.
+ */
+async function fetchBaselineForTemplate(db, _rule, template) {
+    const existing = await findModifiedExceptionForEntity(db, template.id);
+    if (!existing)
+        return null;
+    const meta = existing.metadata;
+    if (!meta.baseline || typeof meta.baseline !== "object" || Array.isArray(meta.baseline)) {
+        return null;
+    }
+    return meta.baseline;
+}
+async function insertNextOccurrence(db, rule, occurrence, nextDueAt, baseline) {
     const occurrenceIndex = rule.generatedCount + 1;
     const idempotencyKey = `recurrence:${rule.id}:${nextDueAt.toISOString()}`;
     const metadata = {
@@ -263,15 +440,15 @@ async function insertNextOccurrence(db, rule, occurrence, nextDueAt) {
     const values = {
         kind: "task",
         projectId: occurrence.projectId,
-        title: occurrence.title,
-        body: occurrence.body,
-        tags: occurrence.tags,
+        title: baseline && "title" in baseline ? baseline.title : occurrence.title,
+        body: baseline && "body" in baseline ? (baseline.body ?? "") : occurrence.body,
+        tags: baseline && "tags" in baseline ? (baseline.tags ?? []) : occurrence.tags,
         status: "open",
         parentId: occurrence.parentId,
         actorKind: "system",
         metadata,
         dueAt: nextDueAt,
-        priority: occurrence.priority,
+        priority: (baseline && "priority" in baseline ? baseline.priority : null) ?? occurrence.priority,
         pinned: false,
         completedAt: null,
         idempotencyKey
@@ -306,7 +483,8 @@ async function advanceRuleFromOccurrence(db, rule, occurrence, completedAt) {
             .where(eq(recurrenceRules.id, rule.id));
         return null;
     }
-    const next = await insertNextOccurrence(db, rule, occurrence, nextDueAt);
+    const baseline = await fetchBaselineForTemplate(db, rule, occurrence);
+    const next = await insertNextOccurrence(db, rule, occurrence, nextDueAt, baseline ?? undefined);
     await db
         .update(recurrenceRules)
         .set({
@@ -318,6 +496,55 @@ async function advanceRuleFromOccurrence(db, rule, occurrence, completedAt) {
         .where(eq(recurrenceRules.id, rule.id));
     return next;
 }
+export async function materializeScheduledRecurrences(db, upTo, limit = 100) {
+    const rows = await db
+        .select()
+        .from(recurrenceRules)
+        .where(and(eq(recurrenceRules.enabled, true), eq(recurrenceRules.anchor, "scheduled"), lte(recurrenceRules.nextOccurrenceAt, upTo)))
+        .orderBy(asc(recurrenceRules.nextOccurrenceAt))
+        .limit(limit);
+    const created = [];
+    for (const originalRule of rows) {
+        let rule = originalRule;
+        let template = await fetchEntity(db, rule.currentOccurrenceId ?? rule.seriesId).catch(() => fetchEntity(db, rule.seriesId));
+        while (rule.enabled &&
+            rule.nextOccurrenceAt &&
+            rule.nextOccurrenceAt.getTime() <= upTo.getTime() &&
+            created.length < limit) {
+            const count = countLimit(rule);
+            if (count != null && rule.generatedCount >= count) {
+                await db
+                    .update(recurrenceRules)
+                    .set({ nextOccurrenceAt: null })
+                    .where(eq(recurrenceRules.id, rule.id));
+                break;
+            }
+            const nextDueAt = normalizeOccurrenceDueAt(rule, rule.nextOccurrenceAt);
+            const baseline = await fetchBaselineForTemplate(db, rule, template);
+            const next = await insertNextOccurrence(db, rule, template, nextDueAt, baseline ?? undefined);
+            created.push(next);
+            const generatedCount = rule.generatedCount + 1;
+            const following = count != null && generatedCount >= count
+                ? null
+                : computeNextScheduledAfter(rule, nextDueAt);
+            const [updated] = await db
+                .update(recurrenceRules)
+                .set({
+                currentOccurrenceId: next.id,
+                generatedCount,
+                lastOccurrenceAt: template.dueAt ?? rule.dtstart,
+                nextOccurrenceAt: following
+            })
+                .where(eq(recurrenceRules.id, rule.id))
+                .returning();
+            if (!updated)
+                break;
+            rule = updated;
+            template = next;
+        }
+    }
+    return created;
+}
 export async function advanceRecurrenceOnCompletion(db, occurrence, completedAt = occurrence.completedAt ?? new Date()) {
     if (occurrence.kind !== "task")
         return null;
@@ -378,4 +605,137 @@ export async function stopRecurrence(db, ruleId, _input = {}) {
         throw new Error(`recurrence rule ${ruleId} not found`);
     return updated;
 }
+/**
+ * Fork a recurrence series at its current occurrence: freeze the old rule and
+ * apply a new cadence going forward, keeping the same series so the UI still
+ * shows one continuous timeline (history + future).
+ *
+ * Mechanics:
+ *  - The old rule is bounded with UNTIL at the fork point and disabled. It stays
+ *    as frozen history (its already-materialized occurrences are untouched).
+ *  - A new enabled rule is created sharing the SAME series_id (UI continuity)
+ *    with the new RRULE. The live occurrence is kept as its template/display
+ *    source.
+ *  - The new rule has a distinct id, so its occurrences live in a disjoint
+ *    idempotency-key space (`recurrence:<ruleId>:<dueAt>`): no duplicate or
+ *    orphan occurrence can appear at the fork even if a date coincides.
+ *  - Scheduled forks let the materializer grow the new rule from the first
+ *    occurrence after the fork; the live occurrence stays on the old rule as the
+ *    tail of history. Completion forks re-home the live occurrence onto the new
+ *    rule so completing it advances the new cadence.
+ *
+ * The whole operation runs in one transaction: the old rule is disabled before
+ * the new one is inserted, so the partial-unique "one enabled rule per series"
+ * index holds at every step.
+ */
+export async function splitRecurrence(db, ruleId, input) {
+    return db.transaction(async (tx) => {
+        const ruleRows = await tx
+            .select()
+            .from(recurrenceRules)
+            .where(eq(recurrenceRules.id, ruleId))
+            .limit(1);
+        const oldRule = ruleRows[0];
+        if (!oldRule)
+            throw new Error(`recurrence rule ${ruleId} not found`);
+        if (!oldRule.enabled)
+            throw new Error("only an active recurrence can be split");
+        if (!oldRule.currentOccurrenceId) {
+            throw new Error("recurrence has no current occurrence to fork from");
+        }
+        const occRows = await tx
+            .select()
+            .from(entities)
+            .where(eq(entities.id, oldRule.currentOccurrenceId))
+            .limit(1);
+        const current = occRows[0];
+        if (!current)
+            throw new Error("recurrence has no current occurrence to fork from");
+        const forkAfter = current.dueAt ?? oldRule.dtstart;
+        const allDay = input.allDay ?? oldRule.allDay;
+        const timezone = input.timezone ?? oldRule.timezone;
+        const anchor = input.anchor ?? (oldRule.anchor === "completion" ? "completion" : "scheduled");
+        const ruleShape = { allDay, timezone };
+        // The forward cadence.
+        const newRrule = buildRRuleFromInput(input, forkAfter);
+        // Resolve the new rule's anchoring before mutating anything, so a bounded
+        // new rule with no occurrences after the fork fails cleanly (no half-split).
+        let dtstart;
+        let nextOccurrenceAt;
+        let generatedCount;
+        if (anchor === "completion") {
+            // Completion series advance on completion, not on a schedule; the re-homed
+            // live occurrence (below) carries the chain.
+            dtstart = forkAfter;
+            nextOccurrenceAt = null;
+            generatedCount = oldRule.generatedCount;
+        }
+        else {
+            const firstRaw = buildRRule({ rrule: newRrule, dtstart: forkAfter }).after(forkAfter, false);
+            if (!firstRaw) {
+                throw new Error("new recurrence has no occurrences after the fork point");
+            }
+            dtstart = normalizeOccurrenceDueAt(ruleShape, firstRaw);
+            nextOccurrenceAt = dtstart;
+            // The new rule has generated nothing yet — the scheduler materializes its
+            // first occurrence (index 1) at dtstart. Starting at 0 keeps COUNT on the
+            // new rule consistent with rrule expansion. UI continuity comes from the
+            // shared series_id, not from this counter.
+            generatedCount = 0;
+        }
+        // 1) Freeze the old rule. Must run before the insert so the partial-unique
+        //    (one enabled rule per series) index is satisfied at every step.
+        await tx
+            .update(recurrenceRules)
+            .set({
+            enabled: false,
+            rrule: applyUntilToRrule(oldRule.rrule, oldRule.dtstart, forkAfter),
+            currentOccurrenceId: anchor === "completion" ? null : oldRule.currentOccurrenceId,
+            lastOccurrenceAt: current.dueAt ?? oldRule.dtstart,
+            nextOccurrenceAt: null,
+            endedAt: new Date()
+        })
+            .where(eq(recurrenceRules.id, oldRule.id));
+        // 2) Insert the new enabled rule, same series_id.
+        const [created] = await tx
+            .insert(recurrenceRules)
+            .values({
+            seriesId: oldRule.seriesId,
+            currentOccurrenceId: current.id,
+            enabled: true,
+            rrule: newRrule,
+            dtstart,
+            timezone,
+            allDay,
+            anchor,
+            maxInstancesAhead: 1,
+            generatedCount,
+            lastOccurrenceAt: anchor === "completion" ? oldRule.lastOccurrenceAt : null,
+            nextOccurrenceAt,
+            endedAt: null
+        })
+            .returning();
+        if (!created)
+            throw new Error("recurrence rule insert returned no row");
+        // 3) Completion fork: re-home the live occurrence onto the new rule so its
+        //    completion advances the new cadence (findRuleForTask routes by the
+        //    marker's ruleId). Scheduled forks leave it on the old rule as history.
+        if (anchor === "completion") {
+            const marker = recurrenceMarker(current);
+            await tx
+                .update(entities)
+                .set({
+                metadata: withRecurrenceMetadata(current, {
+                    ruleId: created.id,
+                    seriesId: created.seriesId,
+                    role: "occurrence",
+                    occurrenceAt: marker?.occurrenceAt ?? (current.dueAt ?? created.dtstart).toISOString(),
+                    occurrenceIndex: marker?.occurrenceIndex ?? created.generatedCount
+                })
+            })
+                .where(eq(entities.id, current.id));
+        }
+        return created;
+    });
+}
 //# sourceMappingURL=recurrence.js.map