@mulmoclaude/core 1.5.0 → 1.7.0

package/dist/feeds/index.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_ids = require("../ids-BnTh3Hl0.cjs");
-const require_ingestTypes = require("../ingestTypes-xX8VpQqh.cjs");
+const require_calendarGrid = require("../calendarGrid-CaS9er8i.cjs");
+const require_ingestTypes = require("../ingestTypes-D1GQdG8e.cjs");
 exports.AGENT_INGEST_KIND = require_ingestTypes.AGENT_INGEST_KIND;
 exports.DEFAULT_FEED_MAX_ITEMS = require_ingestTypes.DEFAULT_FEED_MAX_ITEMS;
-exports.FEED_SCHEDULES = require_ids.FEED_SCHEDULES;
-exports.INGEST_KINDS = require_ids.INGEST_KINDS;
+exports.FEED_SCHEDULES = require_calendarGrid.FEED_SCHEDULES;
+exports.INGEST_KINDS = require_calendarGrid.INGEST_KINDS;
 exports.isFeedSchedule = require_ingestTypes.isFeedSchedule;

package/dist/feeds/index.js

@@ -1,3 +1,3 @@
-import { l as FEED_SCHEDULES, u as INGEST_KINDS } from "../ids-s4GfmE93.js";
-import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../ingestTypes-L59cIGgX.js";
+import { C as FEED_SCHEDULES, w as INGEST_KINDS } from "../calendarGrid-CrGxeCOG.js";
+import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../ingestTypes-XReG-li7.js";
 export { AGENT_INGEST_KIND, DEFAULT_FEED_MAX_ITEMS, FEED_SCHEDULES, INGEST_KINDS, isFeedSchedule };

package/dist/feeds/server/index.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("../../rolldown-runtime-D6vf50IK.cjs");
-const require_ids = require("../../ids-BnTh3Hl0.cjs");
-const require_discovery = require("../../discovery--kRUWed0.cjs");
-const require_server = require("../../server-gEOeV_Nv.cjs");
+const require_calendarGrid = require("../../calendarGrid-CaS9er8i.cjs");
+const require_discovery = require("../../discovery-DYcR83qx.cjs");
+const require_server = require("../../server-l4TZ5Lbf.cjs");
 const require_feeds_paths = require("../paths.cjs");
-const require_ingestTypes = require("../../ingestTypes-xX8VpQqh.cjs");
+const require_ingestTypes = require("../../ingestTypes-D1GQdG8e.cjs");
 const require_notifier = require("../../notifier-tMsAXyXp.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
@@ -912,8 +912,8 @@ exports.DEFAULT_FEED_MAX_ITEMS = require_ingestTypes.DEFAULT_FEED_MAX_ITEMS;
 exports.DEFAULT_FEED_REFRESH_INTERVAL_MS = DEFAULT_FEED_REFRESH_INTERVAL_MS;
 exports.FEEDS_DIR = require_feeds_paths.FEEDS_DIR;
 exports.FEED_REFRESH_TASK_ID = FEED_REFRESH_TASK_ID;
-exports.FEED_SCHEDULES = require_ids.FEED_SCHEDULES;
-exports.INGEST_KINDS = require_ids.INGEST_KINDS;
+exports.FEED_SCHEDULES = require_calendarGrid.FEED_SCHEDULES;
+exports.INGEST_KINDS = require_calendarGrid.INGEST_KINDS;
 exports.configureFeedsHost = configureFeedsHost;
 exports.feedDir = require_feeds_paths.feedDir;
 exports.feedRefreshTaskDef = feedRefreshTaskDef;

package/dist/feeds/server/index.js

@@ -1,8 +1,8 @@
-import { l as FEED_SCHEDULES, u as INGEST_KINDS } from "../../ids-s4GfmE93.js";
-import { N as listItems, V as resolveDataDir, W as safeSlugName, d as storeFor, et as createForwardingLogger, n as discoverCollections, tt as createHostSlot } from "../../discovery-CKR4TOX3.js";
-import { A as buildCollectionActionSeedPrompt, P as readSkillTemplate, j as promptPathsFor } from "../../server-D_6FLygK.js";
+import { C as FEED_SCHEDULES, w as INGEST_KINDS } from "../../calendarGrid-CrGxeCOG.js";
+import { N as listItems, V as resolveDataDir, W as safeSlugName, d as storeFor, et as createForwardingLogger, n as discoverCollections, tt as createHostSlot } from "../../discovery-_fjsluLx.js";
+import { A as buildCollectionActionSeedPrompt, P as readSkillTemplate, j as promptPathsFor } from "../../server-BlIrtGKl.js";
 import { FEEDS_DIR, feedDir, feedStatePath, feedsRoot, ingestStateDir, ingestStatePath } from "../paths.js";
-import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../../ingestTypes-L59cIGgX.js";
+import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../../ingestTypes-XReG-li7.js";
 import { d as publish, n as clear } from "../../notifier-BdA5qzhe.js";
 import path from "node:path";
 import { createHash } from "node:crypto";

package/dist/google/apiClient.d.ts

@@ -1,4 +1,5 @@
 export declare const GOOGLE_API_TIMEOUT_MS: number;
+export declare const HTTP_FORBIDDEN = 403;
 export declare const DEFAULT_LIST_MAX_RESULTS = 10;
 export declare const MAX_LIST_RESULTS = 50;
 /** Carries the HTTP status so callers can branch on it (e.g. an expired
@@ -18,6 +19,11 @@ export interface GoogleRequestInit {
     contentType?: string;
     /** Response is not JSON (Drive media download) — return the raw text. */
     expectText?: boolean;
+    /** Extra request headers, merged after the defaults. Used for conditional
+     *  writes (`If-Match: <etag>`), which is how a caller makes a PATCH fail with
+     *  412 instead of silently overwriting a newer version. Cannot replace
+     *  `Authorization`. */
+    extraHeaders?: Record<string, string>;
 }
 export declare function googleRequest(apiLabel: string, accessToken: string, url: string, init?: GoogleRequestInit): Promise<unknown>;
 export declare const stringField: (record: Record<string, unknown>, key: string) => string;

package/dist/google/calendar.d.ts

@@ -1,28 +1,72 @@
+/** An `If-Match` write whose etag no longer matches — someone else changed the
+ *  event since it was read. */
+export declare const HTTP_PRECONDITION_FAILED = 412;
+/** An `insert` whose caller-supplied event id is already taken. */
+export declare const HTTP_CONFLICT = 409;
+/** Google's status for an event that was deleted; a sync window reports it so
+ *  consumers can remove their copy. Single-sourced — the pull and the push both
+ *  branch on it. */
+export declare const CANCELLED_EVENT_STATUS = "cancelled";
 /** Resolve a declared calendarId to the one the API and the sync-token store
  *  both address. `||` (not `??`) so an empty string also falls back instead of
  *  building a malformed `/calendars//events` URL. Single-sourced because an
  *  omitted id and an explicit "primary" MUST agree everywhere — grouping them
  *  apart while they share a sync token silently loses events (#2184). */
 export declare const canonicalCalendarId: (calendarId: string | undefined) => string;
-export interface CalendarEventInput {
-    summary: string;
+/** One end of an event as the API expresses it: a timed instant, or a whole day.
+ *
+ *  `timeZone` names the zone a `dateTime` WITHOUT an offset is read in — the
+ *  shape a collection push needs, since the stored clock carries no offset
+ *  (`pushDateTime.ts`). A `dateTime` that already ends in `Z`/`+09:00` needs no
+ *  `timeZone`. `date` is an all-day event, whose `end` Google treats as
+ *  EXCLUSIVE. */
+export type CalendarEventTime = {
+    dateTime: string;
+    timeZone?: string;
+} | {
+    date: string;
+};
+/** The two ways to state an event's span. The flat pair is what the `google`
+ *  tool passes (RFC3339 with an offset); the structured pair is what a push
+ *  needs to express an all-day event or an explicit zone. Expressed as a union
+ *  so "neither given" cannot typecheck on a create. */
+export type CalendarEventSpan = {
     startDateTime: string;
     endDateTime: string;
+} | {
+    start: CalendarEventTime;
+    end: CalendarEventTime;
+};
+export type CalendarEventInput = {
+    summary: string;
     description?: string;
     /** Calendar to create the event on; defaults to the user's primary. */
     calendarId?: string;
     /** Event colour (Google event palette id "1".."11"); omit to inherit the calendar's colour. */
     colorId?: string;
-}
+    /** Caller-chosen event id. Google requires base32hex (`0-9a-v`), 5-1024 chars,
+     *  and answers 409 when it is already taken. A collection push sets this so a
+     *  locally-created record keeps its own record id as the event id, instead of
+     *  being re-keyed to Google's after the fact — a re-key that is missed leaves
+     *  a duplicate record on the next pull. */
+    eventId?: string;
+} & CalendarEventSpan;
 export interface UpdateCalendarEventInput {
     eventId: string;
     summary?: string;
     startDateTime?: string;
     endDateTime?: string;
+    /** Structured span; wins over the flat pair when both are present. */
+    start?: CalendarEventTime;
+    end?: CalendarEventTime;
     /** `""` clears the description; omit to leave it untouched. */
     description?: string;
     calendarId?: string;
     colorId?: string;
+    /** Etag of the version this edit was computed against. Sent as `If-Match`, so
+     *  Google answers 412 rather than letting the PATCH clobber a change that
+     *  landed after the caller read the event. Omit for an unconditional write. */
+    ifMatch?: string;
 }
 export interface DeleteCalendarEventInput {
     eventId: string;
@@ -55,6 +99,10 @@ export interface CalendarSummary {
     foregroundColor: string;
     /** Calendar palette id backing background/foregroundColor. */
     colorId: string;
+    /** IANA zone (`Asia/Tokyo`). The zone a pushed `dateTime` without an offset is
+     *  read in: the collection stores the clock the user reads off THIS calendar,
+     *  so this is the only correct zone to re-attach. `""` when Google omits it. */
+    timeZone: string;
 }
 export interface CalendarColorEntry {
     background: string;
@@ -71,17 +119,31 @@ export declare const toCalendarSummary: (value: unknown) => CalendarSummary;
 /** Kept as a named export for the existing unit tests / callers; the shared
  *  helper now carries the wording. */
 export declare const calendarApiError: (status: number, body: string) => Error;
+/** Normalise either spelling of a span into the pair the API body carries. */
+export declare const resolveEventSpan: (span: CalendarEventSpan) => {
+    start: CalendarEventTime;
+    end: CalendarEventTime;
+};
 export declare function createCalendarEvent(accessToken: string, input: CalendarEventInput): Promise<CalendarEventSummary>;
-/** PATCH body for an event edit — only the fields the caller actually supplied.
- *
- *  `undefined` means "leave as is" and `""` means "clear it", so the two cannot
- *  be collapsed: dropping `description: ""` would silently ignore a request to
- *  empty the body text. Pure so the distinction is testable without network. */
 export declare const buildEventPatch: (input: UpdateCalendarEventInput) => Record<string, unknown>;
 /** Edit an existing event in place. PATCH, not PUT — a PUT would need the whole
  *  event and would drop every field the caller never read (attendees,
  *  reminders, recurrence). */
 export declare function updateCalendarEvent(accessToken: string, input: UpdateCalendarEventInput): Promise<CalendarEventSummary>;
+/** An event plus the version token a conditional write needs. */
+export interface FetchedCalendarEvent {
+    event: CalendarEventSummary;
+    /** Google's `etag` for this version, `""` when absent. Sent back as
+     *  `If-Match` so a PATCH cannot overwrite a version we never read. */
+    etag: string;
+}
+/** Read ONE event, or null when it is gone (404 / 410).
+ *
+ *  A push needs Google's current value per changed record to tell a local-only
+ *  edit from a both-sides conflict. Deliberately not `syncCalendarEvents`: that
+ *  consumes the calendar's sync token, and the token's window is served once —
+ *  spending it here would make the next pull miss everything in it. */
+export declare function getCalendarEvent(accessToken: string, input: DeleteCalendarEventInput): Promise<FetchedCalendarEvent | null>;
 /** Remove an event. Google answers 204 with no body, so there is nothing to
  *  return; a second delete of the same id answers 410, which surfaces as a
  *  GoogleApiError rather than being swallowed. */
@@ -126,6 +188,15 @@ export declare function collectCalendarPages(fetchPage: (pageToken?: string) =>
 /** The calendars the user has added/subscribed to (primary + secondary +
  *  shared), each with its id, name and colour, following pagination. Needs the
  *  calendar-list read scope (GOOGLE_CALENDARLIST_SCOPE). */
+/** One calendar's own resource, addressed by id rather than looked up in the
+ *  user's list.
+ *
+ *  `calendarList` only holds calendars the user has ADDED; a calendar shared
+ *  with them can be readable and writable by id without appearing there. This is
+ *  how a push learns such a calendar's `timeZone`. Note the resource carries no
+ *  `accessRole` — that is a calendarList property — so reachability here says
+ *  nothing about writability. */
+export declare function getCalendar(accessToken: string, calendarId: string | undefined): Promise<CalendarSummary>;
 export declare function listCalendars(accessToken: string): Promise<CalendarSummary[]>;
 /** Resolve a `colorId` (on an event or calendar) to its hex background/foreground. */
 export declare function getCalendarColors(accessToken: string): Promise<CalendarColors>;

package/dist/google/calendarPushState.d.ts

@@ -0,0 +1,17 @@
+import { CalendarEventSummary } from './calendar.js';
+/** The pushable subset of an event. `htmlLink` and `status` are read-only on
+ *  Google's side, so a baseline for them could never be acted on. */
+export type ShadowEvent = Pick<CalendarEventSummary, "summary" | "start" | "end" | "colorId">;
+/** `<workspace>/data/calendar/.push-state.json` */
+export declare function calendarPushStatePath(workspaceRoot?: string): string;
+export declare const toShadowEvent: (event: CalendarEventSummary) => ShadowEvent;
+export declare function loadCalendarShadow(calendarId?: string, workspaceRoot?: string): Promise<Record<string, ShadowEvent>>;
+/** Apply a batch to one calendar's baseline. `null` removes an entry (the event
+ *  was cancelled), so a cancel-then-recreate cannot resume from a stale one.
+ *  Merged rather than replaced: a sync window describes only what changed. */
+export declare function mergeShadow(current: Record<string, ShadowEvent>, updates: Record<string, ShadowEvent | null>): Record<string, ShadowEvent>;
+export declare function saveCalendarShadow(calendarId: string | undefined, updates: Record<string, ShadowEvent | null>, workspaceRoot?: string): Promise<void>;
+/** Drop one calendar's whole baseline. Called wherever the sync token is
+ *  cleared: a baseline outliving its token would let a push diff against events
+ *  the workspace no longer holds. */
+export declare function clearCalendarShadow(calendarId?: string, workspaceRoot?: string): Promise<void>;

package/dist/google/collectionPush.d.ts

@@ -0,0 +1,64 @@
+import { LoadedCollection } from '../collection/server/discoveredCollection.js';
+/** What the up-front writability gate knows about the target calendar. */
+export interface CalendarWriteTarget {
+    /** The role from the user's calendar LIST, or null when the calendar is not in
+     *  it. Null means unknown, never read-only: `calendarList` holds only the
+     *  calendars the user has added, so one shared with write access can be absent
+     *  from it (Codex review). */
+    accessRole: string | null;
+    /** IANA zone for rebuilding a zone-less stored clock, `""` when unreported. */
+    timeZone: string;
+}
+/** Whether to refuse the whole push before touching a single event.
+ *
+ *  Only on POSITIVE evidence of a non-writable role. An unlisted calendar is
+ *  unknown and must fall through: hard-denying it would block the feature
+ *  outright for a calendar the user can in fact write to. Those attempts surface
+ *  Google's own 403 per record if the write really is not allowed. */
+export declare const isDeniedAccessRole: (accessRole: string | null) => boolean;
+export interface CalendarCollectionPushResult {
+    slug: string;
+    created: number;
+    updated: number;
+    /** Edited on both sides; skipped so neither version is destroyed. */
+    conflicts: number;
+    /** Records deleted locally. Reported only — v1 never deletes in Google. */
+    localDeletes: number;
+    /** Records that cannot be pushed as they stand, each with the reason. */
+    skipped: string[];
+    errors: string[];
+}
+export type CalendarPushOutcome = {
+    kind: "pushed";
+    result: CalendarCollectionPushResult;
+} | {
+    kind: "not-a-calendar";
+} | {
+    kind: "not-linked";
+} | {
+    kind: "read-only";
+    accessRole: string;
+}
+/** The push never got as far as a record: a revoked grant, an unreachable
+ *  Calendar API, a workspace read failure. Typed rather than left to throw so
+ *  the route answers in the same shape as the other setup problems instead of
+ *  an opaque 500. */
+ | {
+    kind: "failed";
+    message: string;
+};
+/** The I/O a push crosses, injected so every outcome can be exercised with fakes
+ *  instead of a workspace on disk and a live Google grant. */
+export interface CalendarPushDeps {
+    findCollection: (slug: string, workspaceRoot: string) => Promise<LoadedCollection | null>;
+    isLinked: () => Promise<boolean>;
+    accessToken: () => Promise<string>;
+    calendarMeta: (accessToken: string, calendarId: string | undefined) => Promise<CalendarWriteTarget>;
+}
+/** Push ONE collection's records to the calendar it declares.
+ *
+ *  "Does this collection sync at all" is answered before "is Google linked", for
+ *  the reason `syncCalendarForCollection` gives: telling someone to link their
+ *  account for a collection that never declared a calendar sends them fixing the
+ *  wrong thing. */
+export declare function pushCalendarForCollection(slug: string, workspaceRoot: string, deps?: CalendarPushDeps): Promise<CalendarPushOutcome>;

package/dist/google/collectionSync.d.ts

@@ -4,6 +4,7 @@ import { DeleteItemResult, WriteItemResult } from '../collection/server/io.js';
 import { CollectionFieldSpec, CollectionItem } from '../collection/core/schema.js';
 import { GOOGLE_CALENDAR_SOURCE_FIELDS } from '../collection/core/schemaZ.js';
 import { CalendarEventSummary } from './calendar.js';
+import { ShadowEvent } from './calendarPushState.js';
 export declare const GOOGLE_CALENDAR_SYNC_TASK_ID = "system:google-calendar-sync";
 export interface CalendarCollectionSyncResult {
     slug: string;
@@ -61,7 +62,16 @@ export declare function withKeyedLock<T>(locks: Map<string, Promise<unknown>>, k
  *  writes are upserts by event id — but it is a wasted full walk. Queued, the
  *  second pass resumes from the token the first just stored and fetches only
  *  what is genuinely new. */
+/** Serialise anything that touches ONE calendar's sync state.
+ *
+ *  Shared with the push path (#2598), not only the pull doors: a push that
+ *  overtakes an in-flight pull would record a baseline for events the pull is
+ *  still writing, so the next push would diff against a future it never saw. */
+export declare function withCalendarLock<T>(calendarId: string | undefined, run: () => Promise<T>): Promise<T>;
 export declare function syncCalendarGroup(calendarId: string | undefined, collections: readonly LoadedCollection[], workspaceRoot: string): Promise<CalendarCollectionSyncResult[]>;
+/** The baseline this window establishes: what Google now says per event, and
+ *  `null` for a cancelled one so a recreate cannot resume from a dead baseline. */
+export declare function shadowUpdates(events: readonly CalendarEventSummary[]): Record<string, ShadowEvent | null>;
 /** Liveness of the collections a sync just wrote to, checked against the skill
  *  dir `deleteCollection` removes. `exists` is injected so the rule is testable
  *  without a filesystem. An empty group has no survivor by definition. */