Fellow connector public (#353)

* feat(google): parse attendee responses from METHOD:REPLY calendar parts

* fix(google): dedupe ICS line unfolding and correct backslash-escape ordering

Factor icsProp's and icsPropLine's shared RFC 5545 line-unfolding and regex
into one matchIcsLine helper. Fix unescapeIcsText's two-pass replacement,
which misread an escaped backslash followed by a literal 'n' (\\n) as a
newline escape; a single-pass scan now handles all four escapes correctly.
Adds tests locking the quoted-parameter colon-scoping invariant and the
backslash-escape ordering fix.

* feat(google): compose succinct notes for attendee responses

* docs(twister): describe NewNote.unread's three read-state behaviours

* feat(google): fold attendee responses onto the event thread

Google emails the meeting organizer a separate notification for every guest
response ("Declined: Team sync @ Tue Aug 4"), each importing as its own,
mostly-boilerplate email thread. The Gmail sync now folds each response onto
the calendar event's own thread as a short note instead, and only falls back
to creating a standalone email thread when the event hasn't synced yet or
when the conversation also carries real correspondence.

* fix(google): keep preview and facets on the surviving message after folding RSVPs

A mixed conversation (an RSVP notification plus a genuine human reply) kept
computing its preview and classifier facets from the notification's headers
and snippet even after that message's note was folded onto the event thread
and dropped. Restrict both to a message whose note survived the fold, falling
back to the previous behavior untouched when nothing was folded.

* docs(twister): clarify NewNote.unread interaction with scoped notes

* fix: keep Granola backfill from touching calendar-event read state

Granola summaries attach as a note to the calendar event's own thread
rather than creating a separate thread. During the initial backfill,
the note carried an unread:false hint intended for its own thread —
but since the note attaches to a thread Granola doesn't own, that hint
would mark the calendar event's thread read instead. Drop it so
backfilled summaries leave the event thread's read state untouched, as
they always have.

Also neutralizes a test fixture subject line in the Gmail connector's
RSVP-fold tests to a generic placeholder, consistent with the other
synthetic fixtures in that file.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JQ7oQtGrvpDYqeEMVt1DRa

* Fellow AI Meeting Notes

* Google Connector Supports iCalUID no matter suffix

* fix(fellow): signal initial sync completion on every exit path

The platform re-stamps a connection's initial-sync-started marker (and
clears any completed marker) on every channel enable, so the "Syncing…"
indicator turns back on each time. Any path out of onChannelEnabled or
syncBatch that returned without reaching channelSyncCompleted left the
connection spinning until the stuck-sync watchdog gave up and mislabelled
a healthy connection as needing to be reconnected.

Four such paths are closed:

- onChannelEnabled's "already synced a wider range" early return now
  signals completion. There is nothing to back-fill, so this IS the
  enable's sync completing, trivially.
- The covered-history marker is now written only once the backfill
  actually reaches the last page, instead of before the sync runs. Writing
  it up front armed the early return above even for a sync that then died
  mid-chain, permanently short-circuiting every later re-enable.
- onChannelDisabled clears that marker. Disabling archives every link, so
  leaving it set made a re-enable take the early return and come back
  with no notes at all.
- syncBatch's missing-state guard (an at-least-once redelivery of the
  batch task) signals completion instead of returning silently.

Also carry syncHistoryMin forward into the continuation state. Dropping it
made every batch after the first re-query with no updated_at_start filter
— a wider result set than the cursor was issued against — so pagination
walked a different list than it started on and re-saved notes the first
batch had already written.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01No4H37BP9u8bYedFKhavoq

---------

Co-authored-by: Kris Braun <kris.braun@gmail.com>
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
Co-authored-by: TobinBraun <your.email@example.com>

Author: 4 people

.changeset/note-unread-connector-semantics.md

@@ -0,0 +1,5 @@
+---
+"@plotday/twister": minor
+---
+
+Changed: `NewNote.unread` now controls read state on the `saveNotes` path. Omitting it leaves the thread's read state untouched, `true` marks the thread unread for everyone but the note's author, and `false` marks it read for the connection owner so a two-way read sync converges. Previously the field had no effect on notes saved through `saveNotes`.

.changeset/options-text-required-field.md

@@ -0,0 +1,5 @@
+---
+"@plotday/twister": minor
+---
+
+Added: `TextDef.required` on the `Options` tool. When set, the Flutter connect/edit form blocks submission while the field is empty (secure fields were already implicitly required). Text fields with no sensible default — like a workspace subdomain — can now opt in to this instead of silently accepting a blank value that only fails once the connector tries to use it.

connectors/fellow/src/fellow-api.ts

@@ -56,6 +56,61 @@ export type ListActionItemsParams = {
   archived?: boolean;
 };
 
+/**
+ * Payload Fellow POSTs to the webhook URL for `ai_note.generated` /
+ * `ai_note.shared_to_channel` events. Carries the AI-generated notes content
+ * directly via `ai_notes` — this is the ONLY place that content is available.
+ * The `/notes` list endpoint's `content_markdown` field renders the note's
+ * agenda/manual content but never includes the AI-generated summary, so
+ * consumers must read `ai_notes` from this payload rather than re-fetching
+ * the note via the API. `id` is the note id (matches `FellowNote.id`);
+ * `event_id` is the calendar event identifier (matches `FellowNote.event_guid`).
+ */
+export type FellowAiNoteWebhook = {
+  event_type: "ai_note.generated" | "ai_note.shared_to_channel";
+  id: string;
+  event_id: string | null;
+  event_title: string | null;
+  event_start: string | null;
+  recap_url: string | null;
+  ai_notes: string | null;
+};
+
+/**
+ * Payload Fellow POSTs to the webhook URL for an `action_item.assigned`
+ * event. Unlike `ai_note.*` events, this carries the full action item —
+ * including `note_id`, which is `null` for a standalone action item created
+ * directly in Fellow (not attached to a meeting note).
+ */
+export type FellowActionItemAssignedWebhook = {
+  event_type: "action_item.assigned";
+  id: string;
+  text: string;
+  assignees: Array<{ id: string; full_name: string; email: string }>;
+  completion_type: string | null;
+  status: FellowActionItem["status"];
+  due_date: string | null;
+  note_id: string | null;
+  ai_generated: boolean;
+  created_at: string;
+  updated_at: string;
+};
+
+/** Payload Fellow POSTs to the webhook URL for an `action_item.completed` event. */
+export type FellowActionItemCompletedWebhook = {
+  event_type: "action_item.completed";
+  id: string;
+  text: string;
+  assignee_id: string | null;
+  assignee_name: string | null;
+  assignee_email: string | null;
+  note_id: string | null;
+  due_date: string | null;
+  done: boolean;
+  wont_do: boolean;
+  ai_generated: boolean;
+};
+
 export class FellowAPI {
   private baseUrl: string;
 
@@ -83,7 +138,11 @@ export class FellowAPI {
       );
     }
 
-    return response.json() as Promise<T>;
+    // Some endpoints (e.g. complete/archive) return no body on success;
+    // JSON.parse("") would throw, so treat an empty body as `undefined`
+    // rather than a malformed response.
+    const text = await response.text();
+    return (text ? JSON.parse(text) : undefined) as T;
   }
 
   async listNotes(params?: ListNotesParams): Promise<{
@@ -147,6 +206,16 @@ export class FellowAPI {
     };
   }
 
+  /** Marks an action item done (`completed: true`) or reopens it (`false`). */
+  async completeActionItem(id: string, completed: boolean): Promise<void> {
+    await this.request<void>(`/action_item/${id}/complete`, { completed });
+  }
+
+  /** Archives an action item (marks it "won't do"). Not reversible via the API. */
+  async archiveActionItem(id: string): Promise<void> {
+    await this.request<void>(`/action_item/${id}/archive`);
+  }
+
   async createWebhook(
     url: string,
     events: string[],