circal-mcp 0.3.0 → 0.4.0

package/dist/circal-mcp.mjs

@@ -2332,10 +2332,9 @@ function occurrencesOn(events, calendars, day) {
         continuesAfter,
         dayIndex: daysBetween(firstDay, dayStart) + 1,
         dayCount: daysBetween(firstDay, lastDay) + 1,
-        // A tick is per occurrence, so it is looked up per occurrence. The
-        // list is empty on everything that is not a task, which is almost
-        // every event in the store.
-        done: event.doneKeys.length > 0 && event.doneKeys.includes(instantKey(start)),
+        // An event is never done — the field exists for a task's occurrences,
+        // resolved in `taskOccurrences`.
+        done: false,
         lane: 0
       });
     }
@@ -2347,22 +2346,99 @@ function packLanes(occurrences, pad2 = 6) {
   const laneEnds = [];
   return occurrences.map((occ) => {
     if (occ.event.allDay) return occ;
-    if (occ.event.task) return occ;
+    if (occ.task && occ.startMin === occ.endMin) return occ;
     let lane = laneEnds.findIndex((end) => end <= occ.startMin + pad2);
     if (lane === -1) lane = laneEnds.length;
     laneEnds[lane] = occ.endMin;
     return { ...occ, lane };
   });
 }
-function dayAgenda(events, calendars, day) {
-  const all = occurrencesOn(events, calendars, day);
+function dayAgenda(events, calendars, day, tasks = []) {
+  const all = [...occurrencesOn(events, calendars, day), ...taskOccurrences(tasks, calendars, day)];
+  all.sort((a, b) => a.start.getTime() - b.start.getTime() || a.end.getTime() - b.end.getTime());
   const allDay = all.filter((o) => o.event.allDay);
   const timed = packLanes(all.filter((o) => !o.event.allDay));
   return { timed, allDay, all: [...allDay, ...timed] };
 }
-function toggleDoneKey(keys, at) {
-  const key = instantKey(at);
-  return keys.includes(key) ? keys.filter((k) => k !== key) : [...keys, key];
+function taskEvent(task, start, end) {
+  return {
+    id: task.id,
+    title: task.title,
+    calendarId: task.calendarId,
+    start,
+    end,
+    allDay: false,
+    tzid: "",
+    location: "",
+    url: "",
+    notes: task.notes,
+    ...NEVER,
+    seriesId: "",
+    seriesKey: "",
+    color: task.color,
+    icon: task.icon,
+    free: false,
+    remindLead: REMIND_INHERIT,
+    organizer: null,
+    attendees: [],
+    attendeeCount: 0,
+    updatedAt: 0
+  };
+}
+function taskOccurrences(tasks, calendars, day) {
+  const hidden = new Set(calendars.filter((c) => !c.visible).map((c) => c.id));
+  const dayStart = startOfDay(day);
+  const dayEnd = addDays(dayStart, 1);
+  const out = [];
+  for (const task of tasks) {
+    if (hidden.has(task.calendarId)) continue;
+    let planned = false;
+    for (const plan of task.plans) {
+      if (plan.end <= dayStart.getTime() || plan.start >= dayEnd.getTime()) continue;
+      planned = true;
+      const start = new Date(plan.start);
+      const end = new Date(plan.end);
+      const continuesBefore = start < dayStart;
+      const continuesAfter = end > dayEnd;
+      const firstDay = startOfDay(start);
+      const lastDay = startOfDay(new Date(Math.max(plan.start, plan.end - 1)));
+      out.push({
+        key: `${task.id}@${instantKey(start)}`,
+        event: taskEvent(task, plan.start, plan.end),
+        task,
+        start,
+        end,
+        startMin: continuesBefore ? 0 : minutesOfDay(start),
+        endMin: end >= dayEnd ? MINUTES_PER_DAY : minutesOfDay(end),
+        continuesBefore,
+        continuesAfter,
+        dayIndex: daysBetween(firstDay, dayStart) + 1,
+        dayCount: daysBetween(firstDay, lastDay) + 1,
+        done: task.done,
+        lane: 0
+      });
+    }
+    if (planned || task.dueAllDay) continue;
+    if (task.due < dayStart.getTime() || task.due >= dayEnd.getTime()) continue;
+    const due = new Date(task.due);
+    out.push({
+      key: `${task.id}@${instantKey(due)}`,
+      event: taskEvent(task, task.due, task.due),
+      task,
+      start: due,
+      end: due,
+      startMin: minutesOfDay(due),
+      endMin: minutesOfDay(due),
+      continuesBefore: false,
+      continuesAfter: false,
+      dayIndex: 1,
+      dayCount: 1,
+      done: task.done,
+      lane: 0
+    });
+  }
+  out.sort((a, b) => a.start.getTime() - b.start.getTime() || a.end.getTime() - b.end.getTime());
+  return out;
 }
 var DEFAULT_WAKING = { from: 8 * 60, to: 22 * 60 };
 function freeGaps(occurrences, minMinutes, from, to) {
@@ -2386,13 +2462,15 @@ function dayLoad(occurrences, waking) {
 }
 var FIELD_PENALTY = { location: 30, notes: 45 };
 var penalise = (score, cost) => score === null ? null : score - cost;
-function scoreEvent(event, query) {
-  const scores = [
-    fuzzyScore(event.title, query),
-    penalise(fuzzyScore(event.location, query), FIELD_PENALTY.location),
-    penalise(fuzzyScore(event.notes, query), FIELD_PENALTY.notes)
-  ].filter((score) => score !== null);
-  return scores.length > 0 ? Math.max(...scores) : null;
+function scoreEventBy(event, query) {
+  let best = null;
+  const consider = (field, score) => {
+    if (score !== null && (best === null || score > best.score)) best = { field, score };
+  };
+  consider("title", fuzzyScore(event.title, query));
+  consider("location", penalise(fuzzyScore(event.location, query), FIELD_PENALTY.location));
+  consider("notes", penalise(fuzzyScore(event.notes, query), FIELD_PENALTY.notes));
+  return best;
 }
 var PALETTE = [
   "#7ce3d8",
@@ -2424,15 +2502,61 @@ function spanLabel(occ) {
 // src/lib/store.ts
 var import_react2 = __toESM(require_react(), 1);
 
+// src/lib/tasks.ts
+var ESTIMATE_MAX = 24 * 60;
+var PLANS_MAX = 32;
+function readEstimate(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.min(ESTIMATE_MAX, Math.max(0, Math.round(value)));
+}
+function readPriority(value) {
+  return value === 1 || value === 2 ? value : 0;
+}
+function readPlans(value) {
+  if (!Array.isArray(value)) return [];
+  const plans = [];
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const { start, end } = entry;
+    if (typeof start !== "number" || typeof end !== "number") continue;
+    if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
+    if (end <= start) continue;
+    plans.push({ start, end });
+    if (plans.length === PLANS_MAX) break;
+  }
+  return plans.sort((a, b) => a.start - b.start || a.end - b.end);
+}
+var DUE_SOON_DAYS = 7;
+function taskState(task, now) {
+  if (task.done) return "done";
+  const today = startOfDay(now);
+  if (task.dueAllDay) {
+    const dueDay = startOfDay(new Date(task.due));
+    if (dueDay < today) return "overdue";
+    return dueDay < addDays(today, DUE_SOON_DAYS + 1) ? "due-soon" : "later";
+  }
+  if (task.due <= now.getTime()) return "overdue";
+  return startOfDay(new Date(task.due)) < addDays(today, DUE_SOON_DAYS + 1) ? "due-soon" : "later";
+}
+var NOTES_PENALTY = 45;
+function scoreTaskBy(task, query) {
+  const title = fuzzyScore(task.title, query);
+  const notes = fuzzyScore(task.notes, query);
+  const penalised = notes === null ? null : notes - NOTES_PENALTY;
+  let best = title === null ? null : { field: "title", score: title };
+  if (penalised !== null && (best === null || penalised > best.score)) {
+    best = { field: "notes", score: penalised };
+  }
+  return best;
+}
+function compareTasks(a, b) {
+  return a.due - b.due || b.priority - a.priority || a.title.localeCompare(b.title);
+}
+
 // src/lib/mutate.ts
 function applyUpdate(events, id, patch, now) {
   return events.map((e) => e.id === id ? { ...e, ...patch, updatedAt: now } : e);
 }
-function applyToggleDone(events, id, at, now) {
-  return events.map(
-    (e) => e.id === id ? { ...e, doneKeys: toggleDoneKey(e.doneKeys, at), updatedAt: now } : e
-  );
-}
 function applyRemove(events, id, now) {
   const buried = events.filter((e) => e.id === id || e.seriesId === id);
   return {
@@ -2789,6 +2913,12 @@ function parseQuickAdd(input, reference, now = /* @__PURE__ */ new Date(), fallb
     repeat
   };
 }
+var EDIT_FILLER = /* @__PURE__ */ new Set([...FILLER, "to", "by"]);
+
+// src/lib/remind.ts
+function remindLabel(minutes) {
+  return minutes === 0 ? "As it starts" : `${formatDuration(minutes)} before`;
+}
 
 // src/lib/theme.ts
 var THEMES = ["midnight", "ember", "paper"];
@@ -3367,7 +3497,10 @@ var DEFAULT_SETTINGS = {
   // `DEFAULT_WAKING`'s own pair: this setting exists to replace the constant,
   // not to disagree with it on day one.
   wakingFrom: DEFAULT_WAKING.from,
-  wakingTo: DEFAULT_WAKING.to
+  wakingTo: DEFAULT_WAKING.to,
+  // Opt-in: writes to the calendar nobody asked for are the one thing an
+  // instrument must never surprise anybody with.
+  autoSchedule: false
 };
 var DEFAULT_CALENDARS = [
   {
@@ -3426,8 +3559,6 @@ function draftEvent(day, startMin, endMin, calendarId, repeat = "never") {
     seriesKey: "",
     color: "",
     icon: "",
-    task: false,
-    doneKeys: [],
     // Busy: a gesture that named a time meant that time to be spoken for.
     free: false,
     // Inheriting, which is the only answer a gesture gives: the drag named a
@@ -3565,13 +3696,12 @@ function readSettings(value) {
     // waking window to the defaults, same as every other bounded field here.
     weekStart: value.weekStart === 0 || value.weekStart === 1 || value.weekStart === 6 ? value.weekStart : DEFAULT_SETTINGS.weekStart,
     wakingFrom: typeof value.wakingFrom === "number" ? value.wakingFrom : DEFAULT_SETTINGS.wakingFrom,
-    wakingTo: typeof value.wakingTo === "number" ? value.wakingTo : DEFAULT_SETTINGS.wakingTo
+    wakingTo: typeof value.wakingTo === "number" ? value.wakingTo : DEFAULT_SETTINGS.wakingTo,
+    // Off unless the backup says so — a restore must not start writing to
+    // the calendar because the field was absent.
+    autoSchedule: value.autoSchedule === true
   };
 }
-var INSTANT_KEY = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/;
-function readDoneKeys(value) {
-  return Array.isArray(value) ? [...new Set(value.filter((k) => typeof k === "string" && INSTANT_KEY.test(k)))] : [];
-}
 function derivedId(value, start, end) {
   const text = (key) => typeof value[key] === "string" ? value[key] : "";
   return `${start}-${fnv1a([start, end, text("title"), text("location"), text("seriesKey")].join("|"))}`;
@@ -3581,8 +3711,7 @@ function readEvent(value) {
   const { id, title, calendarId, start, end } = value;
   if (typeof start !== "number" || typeof end !== "number") return null;
   if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
-  const task = value.task === true;
-  if (task ? end < start : end <= start) return null;
+  if (end <= start) return null;
   return {
     // Derived from the record's own fields, never minted: `Math.random()` gave
     // a different id every read, so the same backup imported twice was two
@@ -3612,11 +3741,6 @@ function readEvent(value) {
     // it has to tell apart. This used to slice at one shared cap, which turned
     // ten of the 247 shipped names into strings matching no path.
     icon: readMark(value.icon),
-    task,
-    // The same instant-key check EXDATE gets, and the same reason: a key this
-    // does not spell matches no occurrence, so it is a row of dead weight that
-    // survives every future export.
-    doneKeys: readDoneKeys(value.doneKeys),
     // Anything other than a literal `true` is busy, which is what an event
     // exported before this field existed was. A truthy string in a
     // hand-edited blob must not quietly take a meeting off the day's total.
@@ -3668,10 +3792,33 @@ function readCalendar(value) {
     ...feedUrl ? { feed: { url: feedUrl, fetchedAt: 0, error: "" } } : {}
   };
 }
+function readTask(value) {
+  if (!isRecord(value)) return null;
+  const { id, title, due } = value;
+  if (typeof id !== "string" || !id) return null;
+  if (typeof due !== "number" || !Number.isFinite(due)) return null;
+  return {
+    id,
+    title: typeof title === "string" ? title : "Untitled",
+    notes: typeof value.notes === "string" ? value.notes : "",
+    calendarId: typeof value.calendarId === "string" ? value.calendarId : "",
+    // The mark and the colour take an event's own validators and defaults.
+    icon: readMark(value.icon),
+    color: typeof value.color === "string" ? value.color : "",
+    due,
+    dueAllDay: value.dueAllDay === true,
+    estimate: readEstimate(value.estimate),
+    priority: readPriority(value.priority),
+    plans: readPlans(value.plans),
+    done: value.done === true,
+    updatedAt: readStamp(value.updatedAt)
+  };
+}
 function readBackup(parsed) {
   if (!isRecord(parsed) || parsed.app !== "circal") return { ok: false, reason: "not-circal" };
   const events = (Array.isArray(parsed.events) ? parsed.events : []).map(readEvent).filter((e) => e !== null);
   const calendars = (Array.isArray(parsed.calendars) ? parsed.calendars : []).map(readCalendar).filter((c) => c !== null);
+  const tasks = (Array.isArray(parsed.tasks) ? parsed.tasks : []).map(readTask).filter((t) => t !== null);
   if (calendars.length === 0) return { ok: false, reason: "no-calendars" };
   const known = new Set(calendars.map((c) => c.id));
   const fallback = calendars[0].id;
@@ -3683,6 +3830,8 @@ function readBackup(parsed) {
       return e.seriesId && !seriesIds.has(e.seriesId) ? { ...parented, seriesId: "", seriesKey: "" } : parented;
     }),
     calendars,
+    // A task's calendar is parked the same way an event's is, same reason.
+    tasks: tasks.map((t) => known.has(t.calendarId) ? t : { ...t, calendarId: fallback }),
     settings: readSettings(parsed.settings),
     // Not through `readSettings`: this is bookkeeping about the object rather
     // than a field of it, and a reader that clamped it into `Settings` would
@@ -3693,7 +3842,7 @@ function readBackup(parsed) {
 }
 
 // src/lib/mirror.ts
-var MIRROR_VERSION = 2;
+var MIRROR_VERSION = 3;
 function settled(calendars) {
   return calendars.map(
     (c) => c.feed ? { ...c, feed: { ...c.feed, fetchedAt: 0, error: "" } } : c
@@ -3707,6 +3856,7 @@ function serialiseMirror(s, rev, zone = localZone()) {
     zone,
     rev,
     events: s.events,
+    tasks: s.tasks,
     calendars: settled(s.calendars),
     settings: s.settings,
     settingsAt: s.settingsAt,
@@ -3727,6 +3877,7 @@ function readMirrorFile(text) {
   const envelope = parsed;
   return {
     events: read.events,
+    tasks: read.tasks,
     calendars: read.calendars,
     settings: read.settings,
     // Both through `readBackup`, which is the boundary that already assumes
@@ -3917,6 +4068,7 @@ async function loadForRead(ctx) {
 }
 function fileStore(ctx) {
   return {
+    transport: `file ${ctx.path}`,
     load: () => loadForRead(ctx),
     write: (mutate) => casWrite(ctx, mutate)
   };
@@ -4238,6 +4390,7 @@ function cloudStore(ctx) {
   }
   let writeQueue2 = Promise.resolve();
   return {
+    transport: `cloud (${ctx.credentials.email || "signed in"})`,
     load: loadOnce,
     write(mutate) {
       const run = writeQueue2.then(() => writeOnce(mutate));
@@ -4571,22 +4724,47 @@ function requireScope(event, scope) {
   }
   return scope;
 }
-function resolveCalendar(calendarId, calendars, settings) {
-  if (calendarId) {
-    const found2 = calendars.find((c) => c.id === calendarId);
-    if (!found2) throw new RefusalError(`no calendar with id "${calendarId}"`);
-    if (found2.feed) {
-      throw new RefusalError(
-        `"${found2.name}" is a subscription \u2014 its events are pulled from a feed, never written to`
-      );
-    }
-    return found2;
+function findCalendar(ref, calendars) {
+  const byId = calendars.find((c) => c.id === ref);
+  if (byId) return byId;
+  const needle = ref.trim().toLowerCase();
+  const matches = needle ? calendars.filter((c) => c.name.toLowerCase().startsWith(needle)) : [];
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    throw new RefusalError(
+      `"${ref}" names ${matches.length} calendars (${matches.map((c) => c.name).join(", ")}) \u2014 use an id from list_calendars`
+    );
+  }
+  throw new RefusalError(`no calendar with id or name "${ref}"`);
+}
+function requireWritable(calendar) {
+  if (calendar.feed) {
+    throw new RefusalError(
+      `"${calendar.name}" is a subscription \u2014 its events are pulled from a feed, never written to`
+    );
   }
+  return calendar;
+}
+function resolveCalendar(calendarId, calendars, settings, pin) {
+  if (calendarId) return requireWritable(findCalendar(calendarId, calendars));
+  if (pin) return requireWritable(findCalendar(pin, calendars));
   const id = defaultCalendarId(calendars, settings.defaultCalendar);
   const found = calendars.find((c) => c.id === id);
   if (!found) throw new RefusalError("there is no calendar to put this on \u2014 create one first");
   return found;
 }
+function defaultedCalendar(calendarId, pin) {
+  return calendarId === void 0 && !pin;
+}
+function scopedToCalendar(contents, ref) {
+  if (!ref) return contents;
+  const calendar = findCalendar(ref, contents.calendars);
+  return {
+    ...contents,
+    events: contents.events.filter((e) => e.calendarId === calendar.id),
+    tasks: contents.tasks.filter((t) => t.calendarId === calendar.id)
+  };
+}
 function refuseIfFeed(event, calendars) {
   const calendar = calendars.find((c) => c.id === event.calendarId);
   if (calendar?.feed) {
@@ -4595,49 +4773,70 @@ function refuseIfFeed(event, calendars) {
     );
   }
 }
-function buildRecurrence(input) {
+function buildRecurrence(input, zone = "") {
   if (!input) return { ...NEVER };
-  const until = input.until ? addDays(fromDayKey(input.until), 1).getTime() - 1 : 0;
+  const boundary = input.until ? addDays(fromDayKey(input.until), 1) : null;
+  const until = boundary ? (zone ? instantOfWall(boundary, zone) : boundary.getTime()) - 1 : 0;
   return readRecurrence({ ...input, until, exdates: [], rdates: [] });
 }
-function resolveSpanForCreate(input, day, defaultDuration) {
-  if (input.task === true) {
-    if (input.start === void 0) throw new RefusalError('a task needs "start" (HH:MM)');
-    const at = atMinutes(day, parseTime(input.start, "start")).getTime();
-    return { start: at, end: at, allDay: false, task: true };
+function spanInstant(day, minutes, zone) {
+  return zone ? instantOfWall(atMinutes(day, minutes), zone) : atMinutes(day, minutes).getTime();
+}
+function zoneFrom(value) {
+  if (value === "") return "";
+  if (!isZone(value)) {
+    throw new RefusalError(
+      `"${value}" is not an IANA time zone this runtime knows \u2014 try "Asia/Seoul"`
+    );
   }
+  return value;
+}
+function leadFrom(value) {
+  if (value === "inherit") return REMIND_INHERIT;
+  if (value === "silent") return REMIND_SILENT;
+  if (readRemindLead(value) !== value) {
+    throw new RefusalError(
+      `"remindLead" must be whole minutes, 0 to ${REMIND_LEAD_MAX} \u2014 got ${value}`
+    );
+  }
+  return value;
+}
+function resolveSpanForCreate(input, day, defaultDuration, zone) {
   const endIsDay = input.end !== void 0 && DATE_KEY_RE.test(input.end);
   const noTimeGiven = input.start === void 0 && (input.end === void 0 || endIsDay) && input.duration === void 0;
   const allDay = input.allDay === true || input.allDay === void 0 && noTimeGiven;
   if (allDay) {
+    if (zone) {
+      throw new RefusalError(
+        'an all-day event carries no clock to zone \u2014 drop "zone" or give a timed "start"'
+      );
+    }
     const days = input.end ? Math.max(1, daysBetween(day, fromDayKey(input.end)) + 1) : 1;
     return {
       start: startOfDay(day).getTime(),
       end: addDays(startOfDay(day), days).getTime(),
-      allDay: true,
-      task: false
+      allDay: true
     };
   }
   if (input.start === void 0) throw new RefusalError('a timed event needs "start" (HH:MM)');
   const startMin = parseTime(input.start, "start");
   const endMin = input.end !== void 0 ? parseTime(input.end, "end") : startMin + (input.duration ?? defaultDuration);
   return {
-    start: atMinutes(day, startMin).getTime(),
-    end: atMinutes(day, endMin).getTime(),
-    allDay: false,
-    task: false
+    start: spanInstant(day, startMin, zone),
+    end: spanInstant(day, endMin, zone),
+    allDay: false
   };
 }
-function resolveSpanForPatch(input, base, anchorMs) {
-  const day = input.date ? parseDay(input.date) : startOfDay(new Date(anchorMs));
-  const task = input.task ?? base.task;
-  if (task) {
-    const startMin2 = input.start !== void 0 ? parseTime(input.start, "start") : minutesOfDay(new Date(anchorMs));
-    const at = atMinutes(day, startMin2).getTime();
-    return { start: at, end: at, allDay: false, task: true };
-  }
+function resolveSpanForPatch(input, base, anchorMs, zone) {
+  const anchorWall = base.tzid ? wallClockIn(anchorMs, base.tzid) : new Date(anchorMs);
+  const day = input.date ? parseDay(input.date) : startOfDay(anchorWall);
   const allDay = input.allDay ?? base.allDay;
   if (allDay) {
+    if (input.zone) {
+      throw new RefusalError(
+        'an all-day event carries no clock to zone \u2014 drop "zone" or give a timed "start"'
+      );
+    }
     const baseDays = Math.max(
       1,
       daysBetween(startOfDay(new Date(base.start)), startOfDay(new Date(base.end)))
@@ -4646,56 +4845,55 @@ function resolveSpanForPatch(input, base, anchorMs) {
     return {
       start: startOfDay(day).getTime(),
       end: addDays(startOfDay(day), days).getTime(),
-      allDay: true,
-      task: false
+      allDay: true
     };
   }
   const baseDurationMin = Math.max(1, Math.round((base.end - base.start) / 6e4));
-  const startMin = input.start !== void 0 ? parseTime(input.start, "start") : minutesOfDay(new Date(anchorMs));
+  const startMin = input.start !== void 0 ? parseTime(input.start, "start") : minutesOfDay(anchorWall);
   const endMin = input.end !== void 0 ? parseTime(input.end, "end") : startMin + (input.duration ?? baseDurationMin);
   return {
-    start: atMinutes(day, startMin).getTime(),
-    end: atMinutes(day, endMin).getTime(),
-    allDay: false,
-    task: false
+    start: spanInstant(day, startMin, zone),
+    end: spanInstant(day, endMin, zone),
+    allDay: false
   };
 }
 function validate(draft) {
   const validated = readEvent({ ...draft, id: "pending" });
   if (!validated)
-    throw new RefusalError("the assembled event failed validation (check start, end and task)");
+    throw new RefusalError("the assembled event failed validation (check start and end)");
   const { id: _drop, ...rest } = validated;
   return rest;
 }
-function buildEventRecord(input, calendars, settings) {
+function buildEventRecord(input, calendars, settings, pin) {
   if (!input.date) throw new RefusalError('an event needs "date" (YYYY-MM-DD)');
   const day = parseDay(input.date);
-  const calendar = resolveCalendar(input.calendarId, calendars, settings);
-  const span = resolveSpanForCreate(input, day, settings.defaultDuration);
+  const calendar = resolveCalendar(input.calendarId, calendars, settings, pin);
+  const zone = input.zone ? zoneFrom(input.zone) : "";
+  const span = resolveSpanForCreate(input, day, settings.defaultDuration, zone);
   return validate({
     title: input.title ?? "",
     calendarId: calendar.id,
     start: span.start,
     end: span.end,
     allDay: span.allDay,
-    tzid: "",
+    // The zone the times were spelled in, kept so every surface can print
+    // both clocks — and so a rule walks that zone's own wall calendar.
+    tzid: zone,
     location: input.location ?? "",
     url: input.url ?? "",
     notes: input.notes ?? "",
-    ...buildRecurrence(input.recurrence),
+    ...buildRecurrence(input.recurrence, zone),
     seriesId: "",
     seriesKey: "",
     color: input.color ?? "",
     icon: input.icon ?? "",
-    task: span.task,
-    doneKeys: [],
     // Busy. There is no tool argument for this yet, and an agent asked to put
     // an hour in the diary means the hour to be spoken for.
     free: false,
-    // Inheriting, for the same reason: no tool argument names a lead, and an
-    // event created with one of its own would be an agent quietly deciding
-    // how much warning its user wants.
-    remindLead: REMIND_INHERIT,
+    // Inheriting unless the caller named a lead of its own — an event created
+    // with one it was not asked for would be an agent quietly deciding how
+    // much warning its user wants.
+    remindLead: input.remindLead !== void 0 ? leadFrom(input.remindLead) : REMIND_INHERIT,
     // Nobody, for the reason there is no tool argument and never will be: an
     // agent has no channel to invite anyone on either, so a guest list it
     // assembled would be a list of people who were never asked.
@@ -4710,34 +4908,34 @@ function buildEventRecord(input, calendars, settings) {
 }
 function applyPatchToEvent(base, input, calendars, settings, anchorMs = base.start) {
   const calendar = input.calendarId !== void 0 ? resolveCalendar(input.calendarId, calendars, settings) : calendars.find((c) => c.id === base.calendarId) ?? resolveCalendar(void 0, calendars, settings);
-  const span = resolveSpanForPatch(input, base, anchorMs);
+  const zone = input.zone !== void 0 ? zoneFrom(input.zone) : base.tzid;
+  const span = resolveSpanForPatch(input, base, anchorMs, zone);
   return validate({
     title: input.title ?? base.title,
     calendarId: calendar.id,
     start: span.start,
     end: span.end,
     allDay: span.allDay,
-    tzid: base.tzid,
+    // The patch's zone, else the base's — cleared with the clock when the
+    // patch flips the event all-day, since an all-day event is never zoned.
+    tzid: span.allDay ? "" : zone,
     location: input.location ?? base.location,
     url: input.url ?? base.url,
     notes: input.notes ?? base.notes,
-    ...input.recurrence ? buildRecurrence(input.recurrence) : recurrenceOf(base),
+    ...input.recurrence ? buildRecurrence(input.recurrence, zone) : recurrenceOf(base),
     seriesId: base.seriesId,
     seriesKey: base.seriesKey,
     color: input.color ?? base.color,
     icon: input.icon ?? base.icon,
-    task: span.task,
-    doneKeys: base.doneKeys,
     // Carried, like every other field a patch does not name: `validate` reads
     // the draft through `backup.readEvent`, which defaults an absent `free`
     // to busy — so leaving it out would quietly rebook a free event the
     // moment its title was edited.
     free: base.free,
-    // Carried for exactly the reason above, and this is the field where it
-    // costs most: an event the user silenced would start speaking again the
-    // moment an assistant fixed a typo in its title, because `readEvent`
-    // reads an absent lead as inheriting.
-    remindLead: base.remindLead,
+    // Carried unless the patch names one — `readEvent` reads an absent lead
+    // as inheriting, so leaving it out would un-silence an event the user
+    // silenced the moment an assistant fixed a typo in its title.
+    remindLead: input.remindLead !== void 0 ? leadFrom(input.remindLead) : base.remindLead,
     // Carried, and this is the field where dropping it would be least
     // recoverable: the guest list is a record of a message somebody else sent,
     // and `readEvent` reads an absent one as no invitation at all — so an
@@ -4755,27 +4953,63 @@ function carried(contents) {
   return {
     events: contents.events,
     calendars: contents.calendars,
+    tasks: contents.tasks,
     settings: contents.settings,
     settingsAt: contents.settingsAt,
     graves: contents.graves
   };
 }
+var ID_SHAPE_RE = /^([0-9a-z]+-[0-9a-z]{6}|x-.+)$/;
+function notFound(contents, id, kind) {
+  const grave = contents.graves.find((g) => g.id === id);
+  if (grave) {
+    return new RefusalError(
+      `no ${kind} with id "${id}" \u2014 deleted ${new Date(grave.at).toISOString()} (a grave for it is in the document, so this writer or another one removed it)`
+    );
+  }
+  if (ID_SHAPE_RE.test(id)) {
+    return new RefusalError(
+      `no ${kind} with id "${id}", and no grave for it either \u2014 the id has this app's shape, so another writer may have dropped or rewritten it; re-read with list_day or search`
+    );
+  }
+  return new RefusalError(`no ${kind} with id "${id}"`);
+}
 function calendarName(calendars, id) {
   return calendars.find((c) => c.id === id)?.name ?? "\u2014";
 }
+function zoneSuffix(event, clock) {
+  if (!event.tzid || event.allDay) return "";
+  const start = formatTimeShort(wallClockIn(event.start, event.tzid), clock);
+  const end = formatTimeShort(wallClockIn(event.end, event.tzid), clock);
+  return ` (${start}\u2013${end} ${event.tzid})`;
+}
 function eventSummaryLine(event, calendars, clock) {
-  const when = event.task ? `${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}` : event.allDay ? `${dayKey(new Date(event.start))} \u2013 ${dayKey(addDays(new Date(event.end), -1))} (all day)` : `${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}\u2013${formatTimeShort(new Date(event.end), clock)}`;
+  const when = event.allDay ? `${dayKey(new Date(event.start))} \u2013 ${dayKey(addDays(new Date(event.end), -1))} (all day)` : `${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}\u2013${formatTimeShort(new Date(event.end), clock)}${zoneSuffix(event, clock)}`;
   return `${event.title || "Untitled"} \u2014 [${calendarName(calendars, event.calendarId)}] \u2014 ${when} \u2014 id=${event.id}`;
 }
+function taskSummaryLine(task, calendars, clock) {
+  const when = task.dueAllDay ? `due ${dayKey(new Date(task.due))}` : `due ${dayKey(new Date(task.due))} ${formatTimeShort(new Date(task.due), clock)}`;
+  const bits = [
+    `${task.title || "Untitled"} (task)`,
+    `[${calendarName(calendars, task.calendarId)}]`,
+    when,
+    task.done ? "done" : "open",
+    ...task.estimate !== null ? [`~${formatDuration(task.estimate)}`] : [],
+    ...task.priority > 0 ? [task.priority === 2 ? "urgent" : "high"] : [],
+    `id=${task.id}`
+  ];
+  return bits.join(" \u2014 ");
+}
 function occurrenceLine(occ, calendars, clock) {
-  const when = occ.event.allDay ? "all day" : occ.event.task ? `${occ.start.toISOString()} (${formatTimeShort(occ.start, clock)})` : `${occ.start.toISOString()} (${formatTimeShort(occ.start, clock)}) \u2013 ${occ.end.toISOString()} (${formatTimeShort(occ.end, clock)})`;
+  const pip = occ.task && occ.start.getTime() === occ.end.getTime();
+  const when = occ.event.allDay ? "all day" : pip ? `${occ.start.toISOString()} (${formatTimeShort(occ.start, clock)}) due` : `${occ.start.toISOString()} (${formatTimeShort(occ.start, clock)}) \u2013 ${occ.end.toISOString()} (${formatTimeShort(occ.end, clock)})`;
   const span = spanLabel(occ);
   const bits = [
     occ.event.title || "Untitled",
     `[${calendarName(calendars, occ.event.calendarId)}]`,
     when,
     ...span ? [span] : [],
-    ...occ.event.task ? [occ.done ? "done" : "open"] : [],
+    ...occ.task ? [occ.done ? "done" : "open"] : [],
     `id=${occ.event.id}`,
     `occurrence=${dayKey(occ.start)}`
   ];
@@ -4784,7 +5018,7 @@ function occurrenceLine(occ, calendars, clock) {
 function listDay(contents, date) {
   assertDateKey(date);
   const day = fromDayKey(date);
-  const agenda = dayAgenda(contents.events, contents.calendars, day);
+  const agenda = dayAgenda(contents.events, contents.calendars, day, contents.tasks);
   const clock = contents.settings.clock;
   return [
     `${date} \u2014 ${agenda.all.length} occurrence${agenda.all.length === 1 ? "" : "s"}`,
@@ -4814,7 +5048,10 @@ function listRange(contents, from, to) {
   let truncated = false;
   for (let i = 0; i < span && !truncated; i++) {
     const day = addDays(fromDay, i);
-    const occs = occurrencesOn(contents.events, contents.calendars, day);
+    const occs = [
+      ...occurrencesOn(contents.events, contents.calendars, day),
+      ...taskOccurrences(contents.tasks, contents.calendars, day)
+    ].sort((a, b) => a.start.getTime() - b.start.getTime() || a.end.getTime() - b.end.getTime());
     if (occs.length === 0) continue;
     lines.push(`${dayKey(day)}:`);
     for (const occ of occs) {
@@ -4831,16 +5068,29 @@ function listRange(contents, from, to) {
 }
 function searchEvents(contents, query, limit = 20) {
   const clock = contents.settings.clock;
-  const scored = contents.events.map((event) => ({ event, score: scoreEvent(event, query) })).filter((s) => s.score !== null).sort((a, b) => b.score - a.score).slice(0, Math.max(0, limit));
+  const cap = Math.max(0, limit);
+  const scored = contents.events.map((event) => ({
+    line: eventSummaryLine(event, contents.calendars, clock),
+    hit: scoreEventBy(event, query)
+  })).concat(
+    contents.tasks.map((task) => ({
+      line: taskSummaryLine(task, contents.calendars, clock),
+      hit: scoreTaskBy(task, query)
+    }))
+  ).filter((s) => s.hit !== null).sort((a, b) => b.hit.score - a.hit.score).slice(0, cap);
   return [
     `"${query}" \u2014 ${scored.length} match${scored.length === 1 ? "" : "es"}`,
-    ...scored.length ? scored.map(({ event }) => eventSummaryLine(event, contents.calendars, clock)) : ["(none)"]
+    // A hit outside the title says so: a notes match on a long note is
+    // otherwise indistinguishable from what the record is called.
+    ...scored.length ? scored.map(
+      ({ line, hit }) => hit.field === "title" ? line : `${line} \u2014 matched ${hit.field}`
+    ) : ["(none)"]
   ].join("\n");
 }
 function freeSlots(contents, date, minutes, from, to) {
   assertDateKey(date);
   const day = fromDayKey(date);
-  const occs = occurrencesOn(contents.events, contents.calendars, day);
+  const occs = dayAgenda(contents.events, contents.calendars, day, contents.tasks).all;
   const fromMin = from !== void 0 ? parseTime(from, "from") : contents.settings.wakingFrom ?? DEFAULT_WAKING.from;
   const toMin = to !== void 0 ? parseTime(to, "to") : contents.settings.wakingTo ?? DEFAULT_WAKING.to;
   const clock = contents.settings.clock;
@@ -4861,24 +5111,56 @@ function listCalendars(contents) {
 }
 function describeEvent(contents, id) {
   const event = contents.events.find((e) => e.id === id);
-  if (!event) throw new RefusalError(`no event with id "${id}"`);
+  if (!event) {
+    const task = contents.tasks.find((t) => t.id === id);
+    if (task) return describeTask(contents, task);
+    throw notFound(contents, id, "event");
+  }
   const calendar = contents.calendars.find((c) => c.id === event.calendarId);
   const clock = contents.settings.clock;
   return [
     `${event.title || "Untitled"}  (id=${event.id})`,
     `Calendar: ${calendarName(contents.calendars, event.calendarId)}${calendar?.feed ? " (subscription, read-only)" : ""}`,
-    event.task ? `Task at ${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}` : event.allDay ? `All day, ${dayKey(new Date(event.start))} to ${dayKey(addDays(new Date(event.end), -1))}` : `${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}\u2013${formatTimeShort(new Date(event.end), clock)}`,
+    event.allDay ? `All day, ${dayKey(new Date(event.start))} to ${dayKey(addDays(new Date(event.end), -1))}` : `${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}\u2013${formatTimeShort(new Date(event.end), clock)}`,
+    // Both clocks for a zoned event — the times above are local, and the
+    // hours the deadline was written in are the ones its owner reasons in.
+    ...event.tzid && !event.allDay ? [
+      `Zone: ${event.tzid} \u2014 ${formatTimeShort(wallClockIn(event.start, event.tzid), clock)}\u2013${formatTimeShort(wallClockIn(event.end, event.tzid), clock)} there`
+    ] : [],
     `Repeats: ${repeats(event) ? describeRule(event) : "never"}`,
+    ...event.remindLead !== REMIND_INHERIT ? [`Remind: ${event.remindLead === REMIND_SILENT ? "silent" : remindLabel(event.remindLead)}`] : [],
     ...event.location ? [`Location: ${event.location}`] : [],
     ...event.url ? [`URL: ${event.url}`] : [],
     ...event.notes ? [`Notes: ${event.notes}`] : [],
-    ...event.seriesId ? [`Overrides one occurrence of id=${event.seriesId} (${event.seriesKey})`] : [],
-    ...event.task ? [
-      `Done: ${event.doneKeys.length} occurrence${event.doneKeys.length === 1 ? "" : "s"} ticked`
-    ] : []
+    ...event.seriesId ? [`Overrides one occurrence of id=${event.seriesId} (${event.seriesKey})`] : []
   ].join("\n");
 }
-function performQuickAdd(contents, text, date) {
+function describeTask(contents, task) {
+  const clock = contents.settings.clock;
+  return [
+    `${task.title || "Untitled"}  (task, id=${task.id})`,
+    `Calendar: ${calendarName(contents.calendars, task.calendarId)}`,
+    task.dueAllDay ? `Due ${dayKey(new Date(task.due))}` : `Due ${dayKey(new Date(task.due))} ${formatTimeShort(new Date(task.due), clock)}`,
+    `Status: ${task.done ? "done" : "open"}`,
+    ...task.estimate !== null ? [`Estimate: ${formatDuration(task.estimate)}`] : [],
+    ...task.priority > 0 ? [`Priority: ${task.priority === 2 ? "urgent" : "high"}`] : [],
+    ...task.plans.length ? task.plans.map(
+      (p) => `Planned: ${dayKey(new Date(p.start))} ${formatTimeShort(new Date(p.start), clock)}\u2013${formatTimeShort(new Date(p.end), clock)}`
+    ) : [],
+    ...task.notes ? [`Notes: ${task.notes}`] : []
+  ].join("\n");
+}
+function syncStatus(contents, transport) {
+  return [
+    `Document: rev ${contents.rev}, format version ${contents.version}, zone ${contents.zone || "(unrecorded)"}`,
+    `Transport: ${transport}`,
+    `Counts: ${contents.events.length} events, ${contents.tasks.length} tasks, ${contents.calendars.length} calendars, ${contents.graves.length} graves`
+  ].join("\n");
+}
+function defaultedSuffix(defaulted) {
+  return defaulted ? " \u2014 calendar defaulted, not named" : "";
+}
+function performQuickAdd(contents, text, date, pin) {
   if (!text.trim()) throw new RefusalError('"text" is empty');
   const reference = date ? parseDay(date) : startOfDay(/* @__PURE__ */ new Date());
   const parsed = parseQuickAdd(text, reference, /* @__PURE__ */ new Date(), contents.settings.defaultDuration);
@@ -4887,7 +5169,7 @@ function performQuickAdd(contents, text, date) {
       `could not read "${text}" as an event \u2014 name something beyond a bare title, e.g. "lunch tomorrow 1pm 45m" or "gym every monday 7am"`
     );
   }
-  const calendar = resolveCalendar(void 0, contents.calendars, contents.settings);
+  const calendar = resolveCalendar(void 0, contents.calendars, contents.settings, pin);
   const record = validate({
     ...draftEvent(parsed.day, parsed.startMin, parsed.endMin, calendar.id),
     title: parsed.title,
@@ -4896,20 +5178,182 @@ function performQuickAdd(contents, text, date) {
   const event = { ...record, id: newId(), updatedAt: Date.now() };
   return {
     mutated: { ...carried(contents), events: [...contents.events, event] },
-    message: `Created ${eventSummaryLine(event, contents.calendars, contents.settings.clock)}`
+    message: `Created ${eventSummaryLine(event, contents.calendars, contents.settings.clock)}` + defaultedSuffix(defaultedCalendar(void 0, pin))
   };
 }
-function performCreateEvent(contents, input) {
-  const record = buildEventRecord(input, contents.calendars, contents.settings);
+var KEYED_ID_PREFIX = "x-";
+function keyedId(key) {
+  return `${KEYED_ID_PREFIX}${key}`;
+}
+function performCreateEvent(contents, input, key, pin) {
+  const suffix = defaultedSuffix(defaultedCalendar(input.calendarId, pin));
+  if (key) {
+    const id = keyedId(key);
+    const existing = contents.events.find((e) => e.id === id);
+    if (existing) {
+      refuseIfFeed(existing, contents.calendars);
+      const record3 = applyPatchToEvent(existing, input, contents.calendars, contents.settings);
+      const events = applyUpdate(contents.events, id, record3, Date.now());
+      const updated = events.find((e) => e.id === id);
+      return {
+        mutated: { ...carried(contents), events },
+        message: `Updated (by key "${key}") ` + eventSummaryLine(updated, contents.calendars, contents.settings.clock) + suffix
+      };
+    }
+    const record2 = buildEventRecord(input, contents.calendars, contents.settings, pin);
+    const event2 = { ...record2, id, updatedAt: Date.now() };
+    return {
+      mutated: { ...carried(contents), events: [...contents.events, event2] },
+      message: `Created ${eventSummaryLine(event2, contents.calendars, contents.settings.clock)}` + suffix
+    };
+  }
+  const record = buildEventRecord(input, contents.calendars, contents.settings, pin);
   const event = { ...record, id: newId(), updatedAt: Date.now() };
   return {
     mutated: { ...carried(contents), events: [...contents.events, event] },
-    message: `Created ${eventSummaryLine(event, contents.calendars, contents.settings.clock)}`
+    message: `Created ${eventSummaryLine(event, contents.calendars, contents.settings.clock)}` + suffix
+  };
+}
+var CREATE_BATCH_MAX = 100;
+function performCreateEvents(contents, inputs, pin) {
+  if (inputs.length === 0) throw new RefusalError('"events" is empty');
+  if (inputs.length > CREATE_BATCH_MAX) {
+    throw new RefusalError(
+      `the batch is capped at ${CREATE_BATCH_MAX} events \u2014 got ${inputs.length}`
+    );
+  }
+  let current = contents;
+  const lines = [];
+  for (const [index, input] of inputs.entries()) {
+    let outcome;
+    try {
+      outcome = performCreateEvent(current, input, input.key, pin);
+    } catch (error) {
+      if (error instanceof RefusalError) {
+        throw new RefusalError(`event ${index + 1} of ${inputs.length}: ${error.message}`);
+      }
+      throw error;
+    }
+    current = { ...current, ...outcome.mutated };
+    lines.push(outcome.message);
+  }
+  return { mutated: carried(current), message: lines.join("\n") };
+}
+var PRIORITY_RANK = { normal: 0, high: 1, urgent: 2 };
+function requireTask(contents, id, tool) {
+  const task = contents.tasks.find((t) => t.id === id);
+  if (task) return task;
+  if (contents.events.some((e) => e.id === id)) {
+    throw new RefusalError(`"${id}" is an event, not a task \u2014 ${tool} works on tasks`);
+  }
+  throw notFound(contents, id, "task");
+}
+function requireValidTask(assembled) {
+  const task = readTask(assembled);
+  if (!task) throw new RefusalError("the assembled task failed validation (check date and time)");
+  return task;
+}
+function performCreateTask(contents, input, pin) {
+  if (!input.date) throw new RefusalError('a task needs "date" (YYYY-MM-DD), its due day');
+  const day = parseDay(input.date);
+  const calendar = resolveCalendar(input.calendarId, contents.calendars, contents.settings, pin);
+  const dueAllDay = input.time === void 0 || input.time === null;
+  const task = requireValidTask({
+    id: newId(),
+    title: input.title ?? "",
+    notes: input.notes ?? "",
+    calendarId: calendar.id,
+    icon: input.icon ?? "",
+    color: input.color ?? "",
+    due: dueAllDay ? startOfDay(day).getTime() : atMinutes(day, parseTime(input.time, "time")).getTime(),
+    dueAllDay,
+    estimate: input.estimate ?? null,
+    priority: PRIORITY_RANK[input.priority ?? "normal"],
+    plans: [],
+    done: false,
+    updatedAt: Date.now()
+  });
+  return {
+    mutated: { ...carried(contents), tasks: [...contents.tasks, task] },
+    message: `Created ${taskSummaryLine(task, contents.calendars, contents.settings.clock)}` + defaultedSuffix(defaultedCalendar(input.calendarId, pin))
   };
 }
+function performUpdateTask(contents, id, patch) {
+  const original = requireTask(contents, id, "update_task");
+  const day = patch.date ? parseDay(patch.date) : startOfDay(new Date(original.due));
+  const dueAllDay = patch.time === null ? true : patch.time !== void 0 ? false : original.dueAllDay;
+  const dueMin = typeof patch.time === "string" ? parseTime(patch.time, "time") : minutesOfDay(new Date(original.due));
+  const calendar = patch.calendarId ? resolveCalendar(patch.calendarId, contents.calendars, contents.settings) : void 0;
+  const next = requireValidTask({
+    ...original,
+    title: patch.title ?? original.title,
+    notes: patch.notes ?? original.notes,
+    calendarId: calendar?.id ?? original.calendarId,
+    color: patch.color ?? original.color,
+    icon: patch.icon ?? original.icon,
+    due: dueAllDay ? startOfDay(day).getTime() : atMinutes(day, dueMin).getTime(),
+    dueAllDay,
+    estimate: patch.estimate !== void 0 ? patch.estimate : original.estimate,
+    priority: patch.priority !== void 0 ? PRIORITY_RANK[patch.priority] : original.priority,
+    updatedAt: Date.now()
+  });
+  return {
+    mutated: {
+      ...carried(contents),
+      tasks: contents.tasks.map((t) => t.id === id ? next : t)
+    },
+    message: `Updated ${taskSummaryLine(next, contents.calendars, contents.settings.clock)}`
+  };
+}
+function performPlanTask(contents, id, date, start, end, duration) {
+  const original = requireTask(contents, id, "plan_task");
+  if (original.done) throw new RefusalError("this task is already done \u2014 nothing to plan");
+  if (original.plans.length >= PLANS_MAX) {
+    throw new RefusalError(`this task already carries ${PLANS_MAX} plans, the cap`);
+  }
+  const day = parseDay(date);
+  const startMin = parseTime(start, "start");
+  const endMin = end !== void 0 ? parseTime(end, "end") : startMin + (duration ?? original.estimate ?? contents.settings.defaultDuration);
+  if (endMin <= startMin) throw new RefusalError('"end" must be after "start"');
+  const plan = { start: atMinutes(day, startMin).getTime(), end: atMinutes(day, endMin).getTime() };
+  const next = {
+    ...original,
+    plans: [...original.plans, plan].sort((a, b) => a.start - b.start || a.end - b.end),
+    updatedAt: Date.now()
+  };
+  const clock = contents.settings.clock;
+  return {
+    mutated: { ...carried(contents), tasks: contents.tasks.map((t) => t.id === id ? next : t) },
+    message: `Planned "${next.title || "Untitled"}" ${date} ${formatTimeShort(new Date(plan.start), clock)}\u2013${formatTimeShort(new Date(plan.end), clock)}`
+  };
+}
+function listTasks(contents, now = /* @__PURE__ */ new Date()) {
+  if (contents.tasks.length === 0) return "No tasks.";
+  const clock = contents.settings.clock;
+  const groups = [
+    ["Overdue", []],
+    ["Due soon", []],
+    ["Later", []],
+    ["Done", []]
+  ];
+  const index = { overdue: 0, "due-soon": 1, later: 2, done: 3 };
+  for (const task of contents.tasks) groups[index[taskState(task, now)]][1].push(task);
+  const sections = groups.filter(([, rows]) => rows.length > 0).map(
+    ([label, rows]) => [
+      `${label} (${rows.length}):`,
+      ...rows.sort(compareTasks).map((t) => `  ${taskSummaryLine(t, contents.calendars, clock)}`)
+    ].join("\n")
+  );
+  return sections.join("\n\n");
+}
 function performUpdateEvent(contents, id, scopeArg, occurrence, patch) {
   const original = contents.events.find((e) => e.id === id);
-  if (!original) throw new RefusalError(`no event with id "${id}"`);
+  if (!original) {
+    if (contents.tasks.some((t) => t.id === id)) {
+      throw new RefusalError(`id "${id}" is a task \u2014 use update_task, plan_task or toggle_done.`);
+    }
+    throw notFound(contents, id, "event");
+  }
   refuseIfFeed(original, contents.calendars);
   const scope = requireScope(original, scopeArg);
   const clock = contents.settings.clock;
@@ -4951,7 +5395,10 @@ function performUpdateEvent(contents, id, scopeArg, occurrence, patch) {
 }
 function performDeleteEvent(contents, id, scopeArg, occurrence) {
   const original = contents.events.find((e) => e.id === id);
-  if (!original) throw new RefusalError(`no event with id "${id}"`);
+  if (!original) {
+    if (contents.tasks.some((t) => t.id === id)) return performDeleteTask(contents, id);
+    throw notFound(contents, id, "event");
+  }
   refuseIfFeed(original, contents.calendars);
   const scope = requireScope(original, scopeArg);
   const title = original.title || "Untitled";
@@ -4992,17 +5439,37 @@ function performDeleteEvent(contents, id, scopeArg, occurrence) {
     message: `Deleted "${title}" from ${dayKey(new Date(at))} on.`
   };
 }
-function performToggleDone(contents, id, occurrence) {
-  const original = contents.events.find((e) => e.id === id);
-  if (!original) throw new RefusalError(`no event with id "${id}"`);
-  if (!original.task) throw new RefusalError(`"${original.title || "Untitled"}" is not a task`);
-  refuseIfFeed(original, contents.calendars);
-  const at = resolveInstant(original, occurrence);
-  const wasDone = original.doneKeys.includes(instantKey(at));
-  const events = applyToggleDone(contents.events, original.id, at, Date.now());
+function performDeleteTask(contents, id) {
+  const task = contents.tasks.find((t) => t.id === id);
+  if (!task) {
+    if (contents.events.some((e) => e.id === id)) {
+      throw new RefusalError(`"${id}" is an event, not a task \u2014 use delete_event`);
+    }
+    throw notFound(contents, id, "task");
+  }
+  return {
+    mutated: {
+      ...carried(contents),
+      tasks: contents.tasks.filter((t) => t.id !== id),
+      graves: [...contents.graves, { id, at: Date.now() }]
+    },
+    message: `Deleted the task "${task.title || "Untitled"}".`
+  };
+}
+function performToggleDone(contents, id, _occurrence) {
+  const original = contents.tasks.find((t) => t.id === id);
+  if (!original) {
+    if (contents.events.some((e) => e.id === id)) {
+      throw new RefusalError(`"${id}" is an event, not a task`);
+    }
+    throw notFound(contents, id, "task");
+  }
+  const tasks = contents.tasks.map(
+    (t) => t.id === id ? { ...t, done: !t.done, updatedAt: Date.now() } : t
+  );
   return {
-    mutated: { ...carried(contents), events },
-    message: `${wasDone ? "Reopened" : "Completed"} "${original.title || "Untitled"}" on ${dayKey(new Date(at))}.`
+    mutated: { ...carried(contents), tasks },
+    message: `${original.done ? "Reopened" : "Completed"} "${original.title || "Untitled"}".`
   };
 }
 function performCreateCalendar(contents, name, color, icon) {
@@ -5079,13 +5546,12 @@ function eventFieldsShape() {
   return {
     title: z.string().optional(),
     date: dateKey("YYYY-MM-DD, local.").optional(),
-    start: z.string().describe("HH:MM, 24-hour local clock. Required for a timed event or a task.").optional(),
+    start: z.string().describe("HH:MM, 24-hour local clock. Required for a timed event.").optional(),
     end: z.string().describe(
       "HH:MM for a timed event, or YYYY-MM-DD (inclusive) for a multi-day all-day event. Alternative to duration."
     ).optional(),
     duration: z.number().describe("Minutes \u2014 an alternative to end, for a timed event.").optional(),
     allDay: z.boolean().describe("Forces an all-day event. Inferred when start, end and duration are all omitted.").optional(),
-    task: z.boolean().describe("A dated to-do (one moment, not a span) rather than an event.").optional(),
     calendarId: z.string().describe(
       "Defaults to the user's default calendar. Must not be a subscription \u2014 those are read-only."
     ).optional(),
@@ -5094,29 +5560,65 @@ function eventFieldsShape() {
     location: z.string().optional(),
     url: z.string().optional(),
     notes: z.string().optional(),
+    zone: z.string().describe(
+      `IANA zone the date and times are written in, e.g. "Asia/Seoul" \u2014 for a deadline abroad. Stored on the event so every surface prints both clocks; timed events only. On update, "" clears it back to floating (local) time, and patched times are read on the event's own zone.`
+    ).optional(),
+    remindLead: z.union([z.number().int().min(0).max(REMIND_LEAD_MAX), z.enum(["inherit", "silent"])]).describe(
+      'Reminder lead: minutes before the start (0 = as it starts), "silent" (never fires), or "inherit" (follow the calendar, then the setting \u2014 the default).'
+    ).optional(),
     recurrence: recurrenceSchema.optional()
   };
 }
+var upsertKeySchema = z.string().regex(/^[A-Za-z0-9._:-]{1,64}$/, "letters, digits, . _ : -, up to 64").describe(
+  "Caller-chosen external key for idempotent upsert: the same key always names the same event, so re-running a mirror updates in place instead of duplicating. Omitted, every call creates a fresh event."
+);
 var createEventFieldsSchema = z.strictObject({
   ...eventFieldsShape(),
-  date: dateKey("YYYY-MM-DD, local.")
+  date: dateKey("YYYY-MM-DD, local."),
+  key: upsertKeySchema.optional()
 });
 var patchEventFieldsSchema = z.strictObject(eventFieldsShape());
+function taskFieldsShape() {
+  return {
+    title: z.string().optional(),
+    date: dateKey("YYYY-MM-DD, local \u2014 the due day.").optional(),
+    time: z.string().nullable().describe(
+      "HH:MM due time, 24-hour local clock. Omit for a deadline that is a date with no time on it; null (on update) clears an existing due time back to that."
+    ).optional(),
+    estimate: z.number().nullable().describe("Minutes of work this looks like. null (on update) clears it back to unknown.").optional(),
+    priority: z.enum(["normal", "high", "urgent"]).optional(),
+    calendarId: z.string().describe(
+      "Defaults to the user's default calendar. Must not be a subscription \u2014 those are read-only."
+    ).optional(),
+    color: z.string().describe("#rrggbb. Empty follows the calendar's own colour.").optional(),
+    icon: z.string().describe("A Phosphor icon name or one emoji. Empty follows the calendar's own mark.").optional(),
+    notes: z.string().optional()
+  };
+}
+var createTaskFieldsSchema = z.strictObject({
+  ...taskFieldsShape(),
+  date: dateKey("YYYY-MM-DD, local \u2014 the due day.")
+});
+var patchTaskFieldsSchema = z.strictObject(taskFieldsShape());
 var SCOPE_DESCRIPTION = 'Required when the target event repeats: "one" (just this occurrence), "future" (this one and everything after), or "all" (the whole series). Ignored when the event does not repeat.';
 var OCCURRENCE_DESCRIPTION = 'Which occurrence, as a YYYY-MM-DD date or a full "YYYY-MM-DDTHH:mm:ss" instant. Required with scope "one" or "future".';
 var scopeSchema = z.enum(["one", "future", "all"]).describe(SCOPE_DESCRIPTION);
 var occurrenceSchema = z.string().describe(OCCURRENCE_DESCRIPTION);
-function registerTools(server, store3) {
+var calendarFilterSchema = z.string().describe("Scope to one calendar \u2014 its id, or a unique name prefix. Omit for every calendar.");
+function registerTools(server, store3, pin) {
   server.registerTool(
     "list_day",
     {
       description: "The agenda for one local day: recurrence expanded, all-day and timed occurrences listed separately, each with its id (for update_event/delete_event/toggle_done), its occurrence key, and \u2014 for a multi-day span \u2014 its Day N/M position.",
-      inputSchema: z.strictObject({ date: dateKey("YYYY-MM-DD, local.") }),
+      inputSchema: z.strictObject({
+        date: dateKey("YYYY-MM-DD, local."),
+        calendar: calendarFilterSchema.optional()
+      }),
       annotations: { readOnlyHint: true }
     },
-    async ({ date }) => guarded(async () => {
+    async ({ date, calendar }) => guarded(async () => {
       const { contents, warning } = await store3.load();
-      return withWarning(listDay(contents, date), warning);
+      return withWarning(listDay(scopedToCalendar(contents, calendar), date), warning);
     })
   );
   server.registerTool(
@@ -5125,28 +5627,33 @@ function registerTools(server, store3) {
       description: `The agenda across several local days, one section per day that has something on it. Capped at ${MAX_RANGE_DAYS} days of span and ${MAX_RANGE_OCCURRENCES} occurrences total \u2014 a wide range may come back truncated, which the response says.`,
       inputSchema: z.strictObject({
         from: dateKey("YYYY-MM-DD, local, inclusive."),
-        to: dateKey("YYYY-MM-DD, local, inclusive.")
+        to: dateKey("YYYY-MM-DD, local, inclusive."),
+        calendar: calendarFilterSchema.optional()
       }),
       annotations: { readOnlyHint: true }
     },
-    async ({ from, to }) => guarded(async () => {
+    async ({ from, to, calendar }) => guarded(async () => {
       const { contents, warning } = await store3.load();
-      return withWarning(listRange(contents, from, to), warning);
+      return withWarning(listRange(scopedToCalendar(contents, calendar), from, to), warning);
     })
   );
   server.registerTool(
     "search",
     {
-      description: "Ranked title/location/notes search over the user's own events (never a subscription's).",
+      description: "Ranked title/location/notes search over the user's own events (never a subscription's). Each result names the field it matched when it was not the title.",
       inputSchema: z.strictObject({
         query: z.string(),
-        limit: z.number().int().min(1).describe("Default 20.").optional()
+        limit: z.number().int().min(1).describe("Default 20.").optional(),
+        calendar: calendarFilterSchema.optional()
       }),
       annotations: { readOnlyHint: true }
     },
-    async ({ query, limit }) => guarded(async () => {
+    async ({ query, limit, calendar }) => guarded(async () => {
       const { contents, warning } = await store3.load();
-      return withWarning(searchEvents(contents, query, limit), warning);
+      return withWarning(
+        searchEvents(scopedToCalendar(contents, calendar), query, limit),
+        warning
+      );
     })
   );
   server.registerTool(
@@ -5157,13 +5664,17 @@ function registerTools(server, store3) {
         date: dateKey("YYYY-MM-DD, local."),
         minutes: z.number().describe("Minimum slot length, in minutes."),
         from: z.string().describe("HH:MM, local. Defaults to the user's waking-hours start.").optional(),
-        to: z.string().describe("HH:MM, local. Defaults to the user's waking-hours end.").optional()
+        to: z.string().describe("HH:MM, local. Defaults to the user's waking-hours end.").optional(),
+        calendar: calendarFilterSchema.optional()
       }),
       annotations: { readOnlyHint: true }
     },
-    async ({ date, minutes, from, to }) => guarded(async () => {
+    async ({ date, minutes, from, to, calendar }) => guarded(async () => {
       const { contents, warning } = await store3.load();
-      return withWarning(freeSlots(contents, date, minutes, from, to), warning);
+      return withWarning(
+        freeSlots(scopedToCalendar(contents, calendar), date, minutes, from, to),
+        warning
+      );
     })
   );
   server.registerTool(
@@ -5204,7 +5715,7 @@ function registerTools(server, store3) {
     },
     async ({ text, date }) => guarded(
       () => store3.write((contents) => {
-        const outcome = performQuickAdd(contents, text, date);
+        const outcome = performQuickAdd(contents, text, date, pin);
         return { result: outcome.mutated, summary: outcome.message };
       })
     )
@@ -5212,13 +5723,30 @@ function registerTools(server, store3) {
   server.registerTool(
     "create_event",
     {
-      description: "Creates an event from explicit fields, for anything quick_add's grammar cannot spell \u2014 a full recurrence, a specific calendar, notes. Every field is validated the same way an imported backup is.",
+      description: "Creates an event from explicit fields, for anything quick_add's grammar cannot spell \u2014 a full recurrence, a specific calendar, notes, a foreign time zone, a reminder lead. Every field is validated the same way an imported backup is. `key` makes the call an idempotent upsert.",
       inputSchema: createEventFieldsSchema,
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
     },
     async (input) => guarded(
       () => store3.write((contents) => {
-        const outcome = performCreateEvent(contents, input);
+        const { key, ...fields } = input;
+        const outcome = performCreateEvent(contents, fields, key, pin);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+  server.registerTool(
+    "create_events",
+    {
+      description: `Creates (or, with a per-record \`key\`, upserts) up to ${CREATE_BATCH_MAX} events in one write \u2014 one revision bump, all-or-nothing: any refused record refuses the whole batch naming which. The convergent way to mirror an external document into the calendar.`,
+      inputSchema: z.strictObject({
+        events: z.array(createEventFieldsSchema).min(1).max(CREATE_BATCH_MAX)
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+    },
+    async ({ events }) => guarded(
+      () => store3.write((contents) => {
+        const outcome = performCreateEvents(contents, events, pin);
         return { result: outcome.mutated, summary: outcome.message };
       })
     )
@@ -5260,13 +5788,27 @@ function registerTools(server, store3) {
       })
     )
   );
+  server.registerTool(
+    "delete_task",
+    {
+      description: "Deletes a task. The same removal delete_event performs on a task id \u2014 this name exists so the task verbs read as the set they are (create_task, update_task, delete_task).",
+      inputSchema: z.strictObject({ id: z.string() }),
+      annotations: { destructiveHint: true, idempotentHint: false }
+    },
+    async ({ id }) => guarded(
+      () => store3.write((contents) => {
+        const outcome = performDeleteTask(contents, id);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
   server.registerTool(
     "toggle_done",
     {
-      description: "Ticks a task off, or back on, one occurrence at a time \u2014 never the whole series at once.",
+      description: "Ticks a task off, or back on \u2014 a task has one deadline and is finished once.",
       inputSchema: z.strictObject({
         id: z.string(),
-        occurrence: z.string().describe("YYYY-MM-DD or a full instant. Required for a repeating task.").optional()
+        occurrence: z.string().describe("Accepted for compatibility and ignored \u2014 a task is ticked whole.").optional()
       }),
       annotations: { destructiveHint: false, idempotentHint: false }
     },
@@ -5277,6 +5819,66 @@ function registerTools(server, store3) {
       })
     )
   );
+  server.registerTool(
+    "list_tasks",
+    {
+      description: "Every task, grouped the way the app's own sidebar groups them \u2014 Overdue, Due soon, Later, Done \u2014 soonest deadline first inside each group.",
+      inputSchema: z.strictObject({}),
+      annotations: { readOnlyHint: true }
+    },
+    async () => guarded(async () => {
+      const { contents, warning } = await store3.load();
+      return withWarning(listTasks(contents), warning);
+    })
+  );
+  server.registerTool(
+    "create_task",
+    {
+      description: "Creates a task: a piece of work with a deadline, distinct from an event. `date` is the due day; add `time` for a timed deadline, `estimate` so auto-schedule can size it.",
+      inputSchema: createTaskFieldsSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+    },
+    async (input) => guarded(
+      () => store3.write((contents) => {
+        const outcome = performCreateTask(contents, input, pin);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+  server.registerTool(
+    "update_task",
+    {
+      description: "Patches an existing task. Every field in `patch` is optional and left alone when omitted; ticking is toggle_done's job and planning is plan_task's.",
+      inputSchema: z.strictObject({ id: z.string(), patch: patchTaskFieldsSchema }),
+      annotations: { destructiveHint: true, idempotentHint: false }
+    },
+    async ({ id, patch }) => guarded(
+      () => store3.write((contents) => {
+        const outcome = performUpdateTask(contents, id, patch);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+  server.registerTool(
+    "plan_task",
+    {
+      description: "Books a block of time for a task on the clock \u2014 the drag onto the dial, performed by the assistant. Length falls back to the task's estimate, then the default duration.",
+      inputSchema: z.strictObject({
+        id: z.string(),
+        date: dateKey("YYYY-MM-DD, local \u2014 the day to work on it."),
+        start: z.string().describe("HH:MM, 24-hour local clock."),
+        end: z.string().describe("HH:MM. Alternative to duration.").optional(),
+        duration: z.number().describe("Minutes \u2014 an alternative to end.").optional()
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+    },
+    async ({ id, date, start, end, duration }) => guarded(
+      () => store3.write((contents) => {
+        const outcome = performPlanTask(contents, id, date, start, end, duration);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
   server.registerTool(
     "create_calendar",
     {
@@ -5295,6 +5897,18 @@ function registerTools(server, store3) {
       })
     )
   );
+  server.registerTool(
+    "sync_status",
+    {
+      description: "The document's envelope and shape \u2014 revision, format version, recorded zone, transport, and record counts (events, tasks, calendars, graves). The first tool to reach for when reasoning about sync, a lost record, or a revision that moved.",
+      inputSchema: z.strictObject({}),
+      annotations: { readOnlyHint: true }
+    },
+    async () => guarded(async () => {
+      const { contents, warning } = await store3.load();
+      return withWarning(syncStatus(contents, store3.transport), warning);
+    })
+  );
 }
 
 // mcp/index.ts
@@ -5304,6 +5918,10 @@ Usage:
   circal-mcp --file <path>   Start the server against a mirror file
   circal-mcp --cloud         Start the server against the cloud copy
                               (sign in first with \`circal-mcp login\`)
+  circal-mcp --calendar <c>  Pin this connection's default calendar (an id or
+                              unique name prefix): writes that name none land
+                              on it instead of the user default. Optional,
+                              beside either transport
   circal-mcp login           Sign in to the cloud copy and remember the
                               derived key on this machine (interactive:
                               email, emailed code, passphrase; asks circal.day
@@ -5317,6 +5935,7 @@ Usage:
 
 Environment:
   CIRCAL_FILE                 Mirror file path, same as --file
+  CIRCAL_CALENDAR             Default calendar for writes, same as --calendar
   CIRCAL_CLOUD_CREDENTIALS    Where \`login\` keeps its record (default:
                               the platform config dir, circal/cloud.json)
   CIRCAL_ALLOW_ZONE_MISMATCH   Set to 1 to allow writes when this process's
@@ -5363,9 +5982,11 @@ if (argv.includes("--cloud")) {
   }
   store2 = fileStore({ path, env: process.env });
 }
+var calendarFlag = argv.indexOf("--calendar");
+var pinned = (calendarFlag >= 0 ? argv[calendarFlag + 1] : void 0) || process.env.CIRCAL_CALENDAR;
 function createServer() {
   const server = new McpServer({ name: "circal", version: "1.0.0" });
-  registerTools(server, store2);
+  registerTools(server, store2, pinned);
   return server;
 }
 void serveStdio(createServer);