@mulmoclaude/core 5.0.1 → 5.3.0

package/dist/feeds/server/index.cjs

@@ -4,8 +4,8 @@ const require_dist = require("../../dist-Gj7ygaW2.cjs");
 const require_root = require("../../root-BvwBUcol.cjs");
 const require_itemId = require("../../itemId-CGT2J7YK.cjs");
 const require_project = require("../../project-C1ep9pvo.cjs");
-const require_discovery = require("../../discovery-DCMW05Bp.cjs");
-const require_server = require("../../server-rA9FSkl2.cjs");
+const require_discovery = require("../../discovery-CDXYswtw.cjs");
+const require_server = require("../../server-DfYwSX8b.cjs");
 const require_feeds_paths = require("../paths.cjs");
 const require_ingestTypes = require("../../ingestTypes-DsVH9BYy.cjs");
 const require_notifier = require("../../notifier-B65Mvngb.cjs");

package/dist/feeds/server/index.js

@@ -2,8 +2,8 @@ import { a as isErrorWithCode, l as isUnknownArray, s as isRecord$1 } from "../.
 import { t as canonicalRoot } from "../../root-BcS4-Kge.js";
 import { G as INGEST_KINDS, W as FEED_SCHEDULES } from "../../itemId-4P9S_ehz.js";
 import { t as mergeIntoExisting } from "../../project-B0j_Vf_Q.js";
-import { W as resolveDataDir, _t as createForwardingLogger, d as storeFor, k as listItems, n as discoverCollections, q as safeSlugName, vt as createHostSlot } from "../../discovery-CBjI1lx9.js";
-import { F as buildCollectionActionSeedPrompt, I as promptPathsFor, z as readSkillTemplate } from "../../server-BMZ_BcPH.js";
+import { W as resolveDataDir, _t as createForwardingLogger, d as storeFor, k as listItems, n as discoverCollections, q as safeSlugName, vt as createHostSlot } from "../../discovery-B_64PBZU.js";
+import { F as buildCollectionActionSeedPrompt, I as promptPathsFor, z as readSkillTemplate } from "../../server-7POrhHKv.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-GkG7bJdB.js";
 import { d as publish, n as clear } from "../../notifier-vAp5t6wL.js";

package/dist/google/calendar.d.ts

@@ -1,3 +1,8 @@
+/** A GET or DELETE on an event that is not there. Exported because the push's
+ *  delete sweep has to read "already gone" as success, not as a failure to
+ *  retry — a retained baseline would announce the same phantom deletion on
+ *  every run. */
+export declare const EVENT_ABSENT_STATUSES: readonly number[];
 /** 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;
@@ -74,6 +79,12 @@ export interface UpdateCalendarEventInput {
 export interface DeleteCalendarEventInput {
     eventId: string;
     calendarId?: string | undefined;
+    /** Etag of the version this decision was made against. Sent as `If-Match`, so
+     *  Google answers 412 rather than removing an event that changed after it was
+     *  read — the same guard `updateCalendarEvent` takes, and it matters more
+     *  here: a delete cannot be undone from this side. Omit for an unconditional
+     *  delete. */
+    ifMatch?: string | undefined;
 }
 export interface ListEventsInput {
     timeMin?: string | undefined;
@@ -117,6 +128,14 @@ export interface CalendarEventSummary {
     eventType: string;
     /** Google Meet URL, "" when nothing is attached. */
     hangoutLink: string;
+    /** The signed-in user's own `responseStatus`, folded out of `attendees`.
+     *  `""` when Google reported none — which is every event that HAS no
+     *  attendees, so it reads as "nothing said", never as "not going". */
+    selfResponseStatus: string;
+    /** The URL that joins this event's meeting, folded out of
+     *  `conferenceData.entryPoints`. Covers the conferences `hangoutLink` does
+     *  not: Zoom, Teams, anything attached as conference data. */
+    conferenceVideoUri: string;
 }
 export interface CalendarSummary {
     id: string;
@@ -166,6 +185,11 @@ export interface FetchedCalendarEvent {
     /** 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;
+    /** How many people the event lists, `0` for a solo one. Carried here rather
+     *  than on the summary because only the delete guard reads it, and it is the
+     *  one thing that guard cannot get from the record — by then the record is
+     *  gone (`deletePlan.ts`). */
+    attendeeCount: number;
 }
 /** Read ONE event, or null when it is gone (404 / 410).
  *

package/dist/google/collectionPush.d.ts

@@ -1,6 +1,6 @@
 import { LoadedCollection } from '../collection/server/discoveredCollection.js';
 import { CollectionFieldSpec, CollectionItem } from '../collection/core/schema.js';
-import { CalendarEventSummary } from './calendar.js';
+import { deleteCalendarEvent, getCalendarEvent, CalendarEventSummary } from './calendar.js';
 import { ShadowEvent } from './calendarPushState.js';
 import { PushableSourceField } from './pushPlan.js';
 /** What the up-front writability gate knows about the target calendar. */
@@ -31,8 +31,12 @@ export interface CalendarCollectionPushResult {
     updated: number;
     /** Edited on both sides; skipped so neither version is destroyed. */
     conflicts: number;
-    /** Records deleted locally. Reported only — v1 never deletes in Google. */
+    /** Records deleted locally. Reported whether or not the deletion carried, so
+     *  the count still answers "how many rows went away here". */
     localDeletes: number;
+    /** Of those, how many were deleted in Google too. Always `0` unless the
+     *  collection opted in with `propagateDeletes` (#3234). */
+    deletedInGoogle: number;
     /** Records that cannot be pushed as they stand, each with the reason. */
     skipped: string[];
     errors: string[];
@@ -72,6 +76,15 @@ export interface CalendarPushDeps {
     isLinked: () => Promise<boolean>;
     accessToken: () => Promise<string>;
     calendarMeta: (accessToken: string, calendarId: string | undefined) => Promise<CalendarWriteTarget>;
+    /** Read and write for the delete guard. Injected like the rest so a test can
+     *  exercise "this event has attendees" without a grant (#3234).
+     *
+     *  OPTIONAL, unlike the rest: `CalendarPushDeps` is an exported type, and a
+     *  deps object written before these existed must keep satisfying it — the
+     *  more so because a collection that never opted into `propagateDeletes`
+     *  cannot reach either of them. Absent means the live implementation. */
+    fetchEvent?: typeof getCalendarEvent;
+    deleteEvent?: typeof deleteCalendarEvent;
 }
 type PushOutcome = {
     kind: "created";
@@ -114,6 +127,36 @@ export declare function locallyEditedIds(records: readonly CollectionItem[], sha
  *  from the stored baseline alone, so it works precisely when Google is the
  *  thing that is unreachable. */
 export declare function unsentLocalEdits(collection: LoadedCollection, workspaceRoot: string): Promise<string[]>;
+/** What one run's deletions did. `seen` counts every record that went away
+ *  locally, whether or not the deletion carried — so the count means the same
+ *  thing with the feature off as it always did. */
+export interface DeleteSweep {
+    seen: number;
+    deleted: string[];
+    skipped: string[];
+    errors: string[];
+}
+/** What `sweepDeletes` needs, narrowed to the three effects it has. Taken as an
+ *  argument rather than reached for, so the guard can be exercised against
+ *  "this event has attendees" with no grant and no workspace. */
+export interface DeleteSweepDeps {
+    /** What Google currently holds for the event, or null when it is gone. The
+     *  `etag` is the version the decision was made against. */
+    fetchEvent: (eventId: string) => Promise<{
+        attendeeCount: number;
+        etag: string;
+    } | null>;
+    /** Delete it, conditional on that version. */
+    deleteEvent: (eventId: string, ifMatch: string) => Promise<void>;
+    /** Drop the event's baseline entry. */
+    forget: (eventId: string) => Promise<void>;
+}
+/** Carry every local deletion, when the collection opted in.
+ *
+ *  Sequential rather than concurrent: each one writes the shared baseline file,
+ *  and an interrupted run has to leave a state the next run resumes from rather
+ *  than a partially applied batch. */
+export declare function sweepDeletes(eventIds: readonly string[], propagate: boolean, deps: DeleteSweepDeps): Promise<DeleteSweep>;
 /** Push one collection WITHOUT taking the calendar lock.
  *
  *  The caller must already hold it. The scheduled push→pull cycle

package/dist/google/deletePlan.d.ts

@@ -0,0 +1,32 @@
+/** Why an event was left in Google although its record is gone. */
+export type DeleteRefusal = {
+    kind: "has-attendees";
+} | {
+    kind: "already-gone";
+};
+/** An approval carries the version it was made against, so the delete can be
+ *  conditional on it. Keeping the two together is what stops a caller deleting
+ *  against a version the guard never saw. */
+export type DeleteDecision = {
+    ok: true;
+    etag: string;
+} | ({
+    ok: false;
+} & DeleteRefusal);
+/** The message the push reports for a refusal, with the event named. */
+export declare const deleteRefusalMessage: (eventId: string, refusal: DeleteRefusal) => string;
+/** Decide one deletion against what Google currently holds.
+ *
+ *  `null` means the event is already absent — a 404/410 on the read. Nothing to
+ *  delete, and reported apart from a refusal so "we chose not to" never reads
+ *  as "we could not".
+ *
+ *  ANY attendee refuses, including the entry Google adds for the organiser. A
+ *  rule that tried to exclude "only me" would have to work out which entry is
+ *  the user from a payload that may not say, and being wrong there withdraws a
+ *  real invitation. Solo events — the ones this feature exists for — carry no
+ *  attendees at all, so the blunt rule costs them nothing. */
+export declare function planDelete(fetched: {
+    attendeeCount: number;
+    etag: string;
+} | null): DeleteDecision;

package/dist/google/eventDerived.d.ts

@@ -0,0 +1,19 @@
+/** The signed-in user's own `responseStatus` on this event, `""` when Google
+ *  reported none.
+ *
+ *  `""` is the common case, not an edge one: an event with no attendees has no
+ *  entry to mark `self`, which is most of a personal calendar. So it means
+ *  "Google said nothing", never "not going" — filter with `!= "declined"`, not
+ *  with `== "accepted"`, or every solo event disappears too.
+ *
+ *  Google's values: `needsAction`, `declined`, `tentative`, `accepted`. */
+export declare function selfResponseStatus(attendees: unknown): string;
+/** The URL that joins this event's meeting, `""` when it has none.
+ *
+ *  Only the `video` entry point. The others are a phone number and a dial-in
+ *  PIN page, and a column named for joining that sometimes holds `tel:` would
+ *  be worse than one that is empty — the caller can see empty and fall back.
+ *
+ *  `hangoutLink` (#3229) already carries this for Google Meet; this is what
+ *  reaches the events whose conference is Zoom or Teams. */
+export declare function conferenceVideoUri(conferenceData: unknown): string;

package/dist/google/eventSpanInput.d.ts

@@ -0,0 +1,58 @@
+import { CalendarEventTime } from './calendar.js';
+/** Whether `value` is a bare calendar day — the all-day spelling of an event
+ *  time, and the one shape `isIsoDateTimeWithOffset` is built to refuse.
+ *
+ *  Realness comes from the parser the record lint, the calendar grid and the
+ *  push already share, so every surface agrees that `2026-02-30` is not a day.
+ *  The regex runs first because that parser trims, and a value with whitespace
+ *  around it would validate here and then reach Google verbatim. */
+export declare const isCalendarDateOnly: (value: string) => boolean;
+/** One end of a span, or null when it is neither shape Calendar accepts. */
+export declare const toEventTimeInput: (value: string) => CalendarEventTime | null;
+/** The rule every surface states for a value that is neither shape. Shared so
+ *  the tool, the remote host and their tests cannot drift apart. */
+export declare const EVENT_TIME_HINT = "must be an ISO 8601 date-time with a timezone offset (e.g. 2026-07-17T09:00:00+09:00), or a date for an all-day event (e.g. 2026-07-17)";
+/** The same rule with the offending key named, for a surface whose error text
+ *  carries no path of its own. */
+export declare const eventTimeHint: (key: string) => string;
+/** All-day `end` is exclusive, so a one-day event ends on the NEXT day. Spelled
+ *  out because the natural reading of "all day on the 17th" is `end` = the
+ *  17th, which Calendar refuses. */
+export declare const ALL_DAY_END_HINT = "an all-day `end` is EXCLUSIVE \u2014 it is the day AFTER the last day, so a single day on 2026-07-17 needs end 2026-07-18";
+export declare const MIXED_SPAN_HINT = "start and end must both be date-times with an offset, or both be dates for an all-day event \u2014 not one of each";
+/** A lone all-day end cannot be patched: the stored event's kind is unknown
+ *  here, and giving one end of a timed event a `date` makes an event Calendar
+ *  rejects — with a message that names neither end. Both together are
+ *  unambiguous, so that is what the caller is asked for. */
+export declare const LONE_ALL_DAY_HINT = "pass BOTH start and end to move an all-day event \u2014 an all-day `end` is EXCLUSIVE \u2014 it is the day AFTER the last day, so a single day on 2026-07-17 needs end 2026-07-18";
+export interface SpanTimes {
+    start: CalendarEventTime;
+    end: CalendarEventTime;
+}
+export type SpanResult = {
+    ok: true;
+    span: SpanTimes;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Both ends of a create, validated together.
+ *
+ *  Only the all-day ordering is checked: a timed span's ordering depends on the
+ *  two offsets, which Calendar resolves and reports on clearly, while an all-day
+ *  `end <= start` comes back as an opaque 400. Lexicographic comparison is exact
+ *  for `YYYY-MM-DD` — fixed-width, most significant part first. */
+export declare function resolveSpanInput(start: string, end: string): SpanResult;
+export interface PartialSpanTimes {
+    start?: CalendarEventTime;
+    end?: CalendarEventTime;
+}
+export type PartialSpanResult = {
+    ok: true;
+    times: PartialSpanTimes;
+} | {
+    ok: false;
+    reason: string;
+};
+/** The span of an EDIT, where either end may be absent. */
+export declare function resolvePartialSpanInput(start: string | undefined, end: string | undefined): PartialSpanResult;