@agent-native/core 0.164.11 → 0.164.15

package/corpus/templates/calendar/actions/list-events.ts

@@ -554,6 +554,59 @@ async function listLocalBookingEvents(
   });
 }
 
+/**
+ * Which of these Google event ids are backing a still-active booking.
+ *
+ * Deleting such an event without cancelling its booking leaves the row
+ * confirmed, and `shouldShowLocalBookingEvent` then republishes the booking as a
+ * local calendar event — so the "deleted" meeting reappears. Scoped through the
+ * same booking-link access filter as the calendar read.
+ *
+ * Returns `calendarAccountId` so callers can tell which account a booking'"'"'s event
+ * lives on. It is nullable — the column was added after bookings already
+ * existed — so a null must be read as "unknown account", never as "other
+ * account".
+ */
+export async function findBookedGoogleEvents(
+  googleEventIds: readonly string[],
+): Promise<Array<{ googleEventId: string; calendarAccountId: string | null }>> {
+  const ids = Array.from(new Set(googleEventIds.filter(Boolean)));
+  if (ids.length === 0) return [];
+
+  const db = getDb();
+  const links = await db
+    .select({ slug: schema.bookingLinks.slug })
+    .from(schema.bookingLinks)
+    .where(accessFilter(schema.bookingLinks, schema.bookingLinkShares));
+  const slugs = links.map((link) => link.slug);
+  if (slugs.length === 0) return [];
+
+  const rows = await db
+    .select({
+      googleEventId: schema.bookings.googleEventId,
+      calendarAccountId: schema.bookings.calendarAccountId,
+    })
+    .from(schema.bookings)
+    .where(
+      and(
+        inArray(schema.bookings.slug, slugs),
+        ne(schema.bookings.status, "cancelled"),
+        inArray(schema.bookings.googleEventId, ids),
+      ),
+    );
+
+  return rows.flatMap((row) =>
+    row.googleEventId
+      ? [
+          {
+            googleEventId: row.googleEventId,
+            calendarAccountId: row.calendarAccountId ?? null,
+          },
+        ]
+      : [],
+  );
+}
+
 function shouldShowLocalBookingEvent({
   event,
   googleEventIds,

package/corpus/templates/calendar/changelog/2026-08-18-the-agent-can-now-remove-many-meetings-at-once-such-as-every.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-08-18
+---
+
+The agent can now remove many meetings at once, such as every Saturday and Sunday meeting in a range, instead of failing partway through

package/corpus/templates/calendar/server/lib/event-weekday.ts

@@ -0,0 +1,112 @@
+const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+export const WEEKDAY_NAMES = [
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+] as const;
+
+export type WeekdayName = (typeof WEEKDAY_NAMES)[number];
+
+const WEEKDAY_ALIASES = new Map<string, WeekdayName>([
+  ...WEEKDAY_NAMES.map((day) => [day, day] as const),
+  ...WEEKDAY_NAMES.map((day) => [day.slice(0, 3), day] as const),
+  ["tues", "tuesday"],
+  ["thur", "thursday"],
+  ["thurs", "thursday"],
+  ["weekend", "saturday"],
+]);
+
+/**
+ * Accepts the shapes a natural-language request arrives in — "Saturday",
+ * "sat", "SUN", or an array/comma string mixing them — and rejects anything
+ * else loudly. A silently dropped day name would delete a different set of
+ * events than the user asked about.
+ */
+export function normalizeWeekdays(
+  input: string | readonly string[] | undefined,
+): WeekdayName[] {
+  if (input === undefined) return [];
+  const raw = (Array.isArray(input) ? input : String(input).split(","))
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+  const resolved = new Set<WeekdayName>();
+  for (const value of raw) {
+    if (value === "weekend" || value === "weekends") {
+      resolved.add("saturday");
+      resolved.add("sunday");
+      continue;
+    }
+    if (value === "weekday" || value === "weekdays") {
+      for (const day of WEEKDAY_NAMES) {
+        if (day !== "saturday" && day !== "sunday") resolved.add(day);
+      }
+      continue;
+    }
+    const match = WEEKDAY_ALIASES.get(value.replace(/s$/, ""));
+    if (!match) {
+      throw new Error(
+        `Unrecognized day of week: ${value}. Use full or 3-letter English day names.`,
+      );
+    }
+    resolved.add(match);
+  }
+  return WEEKDAY_NAMES.filter((day) => resolved.has(day));
+}
+
+/**
+ * The weekday the user sees for an event, which is the weekday in the calendar
+ * view's timezone — not UTC. A Sunday 5pm America/Los_Angeles meeting is Monday
+ * in UTC, so filtering on the raw ISO string silently misses it and instead
+ * deletes a Monday meeting the user never mentioned.
+ *
+ * All-day starts carry no instant, so their `YYYY-MM-DD` date IS the local day
+ * and must not be re-projected through a timezone.
+ */
+export function eventWeekday(start: string, timezone: string): WeekdayName {
+  if (DATE_ONLY_RE.test(start)) {
+    const [year, month, day] = start.split("-").map(Number);
+    return WEEKDAY_NAMES[new Date(Date.UTC(year, month - 1, day)).getUTCDay()];
+  }
+  const parsed = new Date(start);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(`Invalid event start: ${start}`);
+  }
+  const label = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    weekday: "long",
+  })
+    .format(parsed)
+    .toLowerCase();
+  const match = WEEKDAY_NAMES.find((day) => day === label);
+  if (!match) throw new Error(`Unable to resolve weekday for ${start}`);
+  return match;
+}
+
+export function matchesWeekdays(
+  start: string,
+  timezone: string,
+  weekdays: readonly WeekdayName[],
+): boolean {
+  if (weekdays.length === 0) return true;
+  return weekdays.includes(eventWeekday(start, timezone));
+}
+
+/**
+ * Validate a caller-supplied IANA timezone instead of falling back to UTC.
+ * `normalizeTimezone` silently returns UTC for an unparseable zone, which on a
+ * destructive weekday filter would quietly reclassify every event and delete a
+ * different set of days than the caller named.
+ */
+export function requireValidTimezone(timezone: string): string {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
+  } catch {
+    throw new Error(`Invalid IANA timezone: ${timezone}`);
+  }
+  return timezone;
+}

package/corpus/templates/content/actions/_database-source-utils.ts

@@ -60,6 +60,10 @@ import {
   chunks,
   processWithConcurrency,
 } from "./_batch-utils.js";
+import {
+  LOCAL_FOLDER_SOURCE_TYPE,
+  localFolderSourceIdentityFromMetadata,
+} from "./_local-folder-source.js";
 export { bulkChunkSizeForColumnCount } from "./_batch-utils.js";
 import {
   readBuilderCmsContentEntry,
@@ -176,6 +180,9 @@ type SourceMetadataRecord = {
   connectionId?: string | null;
   connectionLabel?: string | null;
   truthPolicy?: ContentDatabaseSource["metadata"]["truthPolicy"];
+  syncPolicy?: "manual" | "keep_in_sync";
+  liveBridgeEnabled?: boolean;
+  localIdentity?: unknown;
   liveReadConfigured?: boolean;
   lastReadEntryCount?: number;
   lastReadMatchedRowCount?: number;
@@ -4572,14 +4579,19 @@ async function loadSourceSnapshot(
       ? metadata.writeMode
       : undefined;
   const capabilities = normalizeCapabilities(source.capabilitiesJson);
-  if (normalizedWriteMode) {
+  const sourceType = normalizeSourceType(source.sourceType);
+  if (sourceType === LOCAL_FOLDER_SOURCE_TYPE) {
+    capabilities.liveWritesEnabled =
+      metadata.liveBridgeEnabled === true &&
+      metadata.syncPolicy === "keep_in_sync";
+  } else if (normalizedWriteMode) {
     capabilities.liveWritesEnabled = normalizedWriteMode !== "read_only";
   }
 
   // A local-table source shows the target database's *live* title, so renaming
   // the underlying table is reflected here instead of the name frozen at attach.
   let displaySourceName = source.sourceName;
-  if (normalizeSourceType(source.sourceType) === "local-table") {
+  if (sourceType === "local-table") {
     const [target] = await db
       .select({ title: schema.contentDatabases.title })
       .from(schema.contentDatabases)
@@ -4626,6 +4638,17 @@ async function loadSourceSnapshot(
         metadata.truthPolicy === "reviewed_bidirectional"
           ? metadata.truthPolicy
           : undefined,
+      syncPolicy:
+        metadata.syncPolicy === "manual" ||
+        metadata.syncPolicy === "keep_in_sync"
+          ? metadata.syncPolicy
+          : undefined,
+      liveBridgeEnabled:
+        metadata.liveBridgeEnabled === true &&
+        metadata.syncPolicy === "keep_in_sync",
+      localIdentity: localFolderSourceIdentityFromMetadata(
+        metadata.localIdentity,
+      ),
       liveReadConfigured: metadata.liveReadConfigured === true,
       lastReadEntryCount:
         typeof metadata.lastReadEntryCount === "number"

package/corpus/templates/content/actions/_database-utils.ts

@@ -50,6 +50,7 @@ import {
   getDatabaseMutationContract,
 } from "./_database-row-mutation.js";
 import { getAllContentDatabaseSourceSnapshots } from "./_database-source-utils.js";
+import { serializeDocumentSource } from "./_document-source.js";
 import {
   applyFederatedOverlayValues,
   federateSources,
@@ -443,6 +444,7 @@ function serializeDocument(
     databaseMembership: membership
       ? serializeDatabaseMembership(membership)
       : undefined,
+    source: serializeDocumentSource(doc),
     createdAt: doc.createdAt,
     updatedAt: doc.updatedAt,
   };

package/corpus/templates/content/actions/_local-folder-source.ts

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
 
+import { z } from "zod";
+
 import type {
   ContentDatabaseSourceCapabilities,
   ContentDatabaseSourceTruthPolicy,
@@ -7,6 +9,171 @@ import type {
 
 export const LOCAL_FOLDER_SOURCE_TYPE = "local-folder" as const;
 
+export const localFolderOpaqueIdentitySchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(300)
+  .refine(
+    (value) =>
+      !value.includes("/") &&
+      !value.includes("\\") &&
+      !value.includes("..") &&
+      !value.includes("\0"),
+    "Local source identities must be opaque IDs, not paths.",
+  );
+
+const labelSchema = z.string().trim().min(1).max(200);
+
+export const localFolderSourceConnectionMetadataSchema = z
+  .object({
+    repository: z
+      .object({
+        localId: localFolderOpaqueIdentitySchema,
+        providerBinding: z
+          .object({
+            provider: z.literal("github"),
+            repositoryId: localFolderOpaqueIdentitySchema,
+          })
+          .strict()
+          .optional(),
+      })
+      .strict()
+      .optional(),
+    workingCopy: z
+      .object({
+        id: localFolderOpaqueIdentitySchema,
+        repositoryId: localFolderOpaqueIdentitySchema.optional(),
+        kind: z.enum(["persistent", "temporary"]),
+        name: labelSchema,
+        branch: z.string().trim().min(1).max(300).optional(),
+        commit: z.string().trim().min(1).max(300).optional(),
+        deviceId: localFolderOpaqueIdentitySchema,
+      })
+      .strict()
+      .optional(),
+    liveBridgeEnabled: z.boolean().optional().default(false),
+  })
+  .strict();
+
+export type LocalFolderSourceConnectionMetadata = z.infer<
+  typeof localFolderSourceConnectionMetadataSchema
+>;
+
+export type LocalFolderSourceIdentity = {
+  repository?: {
+    localId: string;
+    providerBinding?: { provider: "github"; repositoryId: string };
+  };
+  workingCopy: {
+    id: string;
+    repositoryId?: string;
+    kind: "persistent" | "temporary";
+    name: string;
+    branch?: string;
+    commit?: string;
+    deviceId: string;
+    localOnly: boolean;
+    shareable: boolean;
+  };
+};
+
+export function localFolderSourceIdentityFromMetadata(
+  value: unknown,
+): LocalFolderSourceIdentity | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  const stored = value as {
+    repository?: unknown;
+    workingCopy?: Record<string, unknown>;
+  };
+  const connectionMetadata =
+    localFolderSourceConnectionMetadataSchema.safeParse({
+      repository: stored.repository,
+      workingCopy: stored.workingCopy
+        ? Object.fromEntries(
+            Object.entries(stored.workingCopy).filter(
+              ([key]) => key !== "localOnly" && key !== "shareable",
+            ),
+          )
+        : undefined,
+    });
+  if (!connectionMetadata.success || !connectionMetadata.data.workingCopy) {
+    return undefined;
+  }
+  try {
+    return normalizeLocalFolderSourceIdentity({
+      connectionId: "stored-local-source",
+      label: connectionMetadata.data.workingCopy.name,
+      connectionMetadata: connectionMetadata.data,
+    });
+  } catch {
+    // coercion-ok: invalid legacy metadata is represented as absent optional identity
+    return undefined;
+  }
+}
+
+export function normalizeLocalFolderSourceIdentity(input: {
+  connectionId: string;
+  label: string;
+  connectionMetadata?: LocalFolderSourceConnectionMetadata;
+}): LocalFolderSourceIdentity {
+  const metadata = localFolderSourceConnectionMetadataSchema.parse(
+    input.connectionMetadata ?? {},
+  );
+  const workingCopy = metadata.workingCopy ?? {
+    id: input.connectionId,
+    kind: "persistent" as const,
+    name: input.label,
+    deviceId: "unknown-device",
+  };
+  if (
+    workingCopy.repositoryId &&
+    (!metadata.repository ||
+      workingCopy.repositoryId !== metadata.repository.localId)
+  ) {
+    throw new Error(
+      "Working-copy repositoryId must match the supplied repository identity.",
+    );
+  }
+  return {
+    ...(metadata.repository ? { repository: metadata.repository } : {}),
+    workingCopy: {
+      ...workingCopy,
+      localOnly: workingCopy.kind === "temporary",
+      shareable: workingCopy.kind !== "temporary",
+    },
+  };
+}
+
+export function localFolderObservedRevision(input: {
+  contentHash: string;
+  metadataHash: string;
+}) {
+  return `sha256:${createHash("sha256")
+    .update(`${input.contentHash}:${input.metadataHash}`)
+    .digest("hex")}`;
+}
+
+export function localFolderSourceFileIdentity(input: {
+  workingCopyId: string;
+  relativePath: string;
+  observedRevision: string;
+}) {
+  const relativePath = input.relativePath.replace(/\\/g, "/");
+  if (
+    !relativePath ||
+    relativePath.startsWith("/") ||
+    relativePath.split("/").some((part) => part === "." || part === "..")
+  ) {
+    throw new Error(
+      "Local source file identity requires a safe relative path.",
+    );
+  }
+  return { ...input, relativePath };
+}
+
 export function localFolderSourceId(databaseId: string, connectionId: string) {
   return `content_database_source_local_folder_${createHash("sha256")
     .update(`${databaseId}:${connectionId}`)
@@ -14,7 +181,9 @@ export function localFolderSourceId(databaseId: string, connectionId: string) {
     .slice(0, 32)}`;
 }
 
-export function localFolderSourceCapabilities(): ContentDatabaseSourceCapabilities {
+export function localFolderSourceCapabilities(input?: {
+  liveBridgeEnabled?: boolean;
+}): ContentDatabaseSourceCapabilities {
   return {
     canRefresh: true,
     canCreateChangeSets: true,
@@ -25,7 +194,7 @@ export function localFolderSourceCapabilities(): ContentDatabaseSourceCapabiliti
     canPublish: false,
     canDelete: true,
     canStageLocalRevision: true,
-    liveWritesEnabled: false,
+    liveWritesEnabled: input?.liveBridgeEnabled === true,
     readOnlyRefresh: false,
     canRename: true,
     canReveal: true,
@@ -37,7 +206,16 @@ export function localFolderSourceMetadata(input: {
   connectionId: string;
   label: string;
   truthPolicy: ContentDatabaseSourceTruthPolicy;
+  connectionMetadata?: LocalFolderSourceConnectionMetadata;
 }) {
+  const connectionMetadata = localFolderSourceConnectionMetadataSchema.parse(
+    input.connectionMetadata ?? {},
+  );
+  const identity = normalizeLocalFolderSourceIdentity({
+    connectionId: input.connectionId,
+    label: input.label,
+    connectionMetadata,
+  });
   return {
     primaryKey: "relative_path",
     naturalKeyField: "relative_path",
@@ -47,6 +225,12 @@ export function localFolderSourceMetadata(input: {
     connectionLabel: input.label,
     truthPolicy: input.truthPolicy,
     writeMode: "stage_only" as const,
+    syncPolicy:
+      connectionMetadata.liveBridgeEnabled === true
+        ? ("keep_in_sync" as const)
+        : ("manual" as const),
+    liveBridgeEnabled: connectionMetadata.liveBridgeEnabled === true,
+    localIdentity: identity,
     notes:
       "The trusted local bridge owns the folder handle or path; SQL stores only this opaque connection identity.",
   };

package/corpus/templates/content/actions/connect-local-folder-source.ts

@@ -17,6 +17,8 @@ import {
 } from "./_content-spaces.js";
 import {
   LOCAL_FOLDER_SOURCE_TYPE,
+  localFolderSourceConnectionMetadataSchema,
+  localFolderOpaqueIdentitySchema,
   localFolderSourceCapabilities,
   localFolderSourceId,
   localFolderSourceMetadata,
@@ -30,12 +32,15 @@ export default defineAction({
   description:
     "Connect an opaque trusted local-folder handle to a canonical Files database. The browser or Desktop bridge keeps the real handle/path; Content stores only safe connection metadata.",
   schema: z.object({
-    connectionId: z
-      .string()
-      .min(1)
-      .max(300)
-      .describe("Stable opaque ID from the trusted browser/Desktop registry"),
+    connectionId: localFolderOpaqueIdentitySchema.describe(
+      "Stable opaque ID from the trusted browser/Desktop registry",
+    ),
     label: z.string().min(1).max(200).describe("User-visible folder label"),
+    connectionMetadata: localFolderSourceConnectionMetadataSchema
+      .optional()
+      .describe(
+        "Safe repository/working-copy identity from the trusted local bridge; raw paths and handles are not accepted.",
+      ),
     spaceId: z
       .string()
       .optional()
@@ -70,9 +75,10 @@ export default defineAction({
     }
 
     const db = getDb();
-    const connectionId = args.connectionId.trim();
+    const connectionId = args.connectionId;
     const label = args.label.trim();
     const truthPolicy = args.truthPolicy as ContentDatabaseSourceTruthPolicy;
+    const connectionMetadata = args.connectionMetadata;
     if (args.dryRun) {
       const [existing] = await db
         .select({
@@ -185,9 +191,18 @@ export default defineAction({
       sourceTable: connectionId,
       syncState: "linked",
       freshness: "unknown",
-      capabilitiesJson: JSON.stringify(localFolderSourceCapabilities()),
+      capabilitiesJson: JSON.stringify(
+        localFolderSourceCapabilities({
+          liveBridgeEnabled: connectionMetadata?.liveBridgeEnabled,
+        }),
+      ),
       metadataJson: JSON.stringify(
-        localFolderSourceMetadata({ connectionId, label, truthPolicy }),
+        localFolderSourceMetadata({
+          connectionId,
+          label,
+          truthPolicy,
+          connectionMetadata,
+        }),
       ),
       lastError: null,
       createdAt: now,

package/corpus/templates/content/actions/disconnect-local-folder-source.ts

@@ -80,7 +80,7 @@ export default defineAction({
         documentId: string;
         sourceDisplayKey: string | null;
         sourceValuesJson: string | null;
-        sourceName: string;
+        sourceTable: string;
       };
       const remainingLocalRows: RemainingLocalRow[] = documentIds.length
         ? await tx
@@ -90,7 +90,7 @@ export default defineAction({
                 schema.contentDatabaseSourceRows.sourceDisplayKey,
               sourceValuesJson:
                 schema.contentDatabaseSourceRows.sourceValuesJson,
-              sourceName: schema.contentDatabaseSources.sourceName,
+              sourceTable: schema.contentDatabaseSources.sourceTable,
             })
             .from(schema.contentDatabaseSourceRows)
             .innerJoin(
@@ -152,7 +152,7 @@ export default defineAction({
             sourceMode: "local-files",
             sourceKind: "file",
             sourcePath: relativePath,
-            sourceRootPath: remaining.sourceName,
+            sourceRootPath: remaining.sourceTable,
             sourceUpdatedAt: now,
             updatedAt: now,
           })

package/corpus/templates/content/actions/resolve-local-folder-conflict.ts

@@ -227,7 +227,7 @@ export default defineAction({
           .select({
             sourceDisplayKey: schema.contentDatabaseSourceRows.sourceDisplayKey,
             sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
-            sourceName: schema.contentDatabaseSources.sourceName,
+            sourceTable: schema.contentDatabaseSources.sourceTable,
           })
           .from(schema.contentDatabaseSourceRows)
           .innerJoin(
@@ -267,7 +267,7 @@ export default defineAction({
                   sourceMode: "local-files",
                   sourceKind: "file",
                   sourcePath: remainingPath ?? null,
-                  sourceRootPath: remainingLocalRow.sourceName,
+                  sourceRootPath: remainingLocalRow.sourceTable,
                   sourceUpdatedAt: now,
                   updatedAt: now,
                 }