@agent-native/core 0.164.11 → 0.164.12

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/factory/AGENTS.md

@@ -71,7 +71,8 @@ decisions, feedback, agent runs, and provider audit records.
 | `suggest-factory-rules` | Mine feedback into proposals. |
 | `reconcile-triage-run` | Persist callback/provider reconciliation. |
 | `list-factories` / `get-factory-graph` | Inspect definitions, versions, and metrics. |
-| `save-factory-graph` | Create or version a complete visual graph; never starts provider work. |
+| `save-factory-graph` | Create/version a graph with inspected `expectedGraphVersion`; never starts provider work. |
+| graph history actions | Factory graph version history. |
 | `list-factory-comments` / `add-factory-comment` | Read or attach comments to a canvas, node, or edge. |
 | `provider-api-catalog` / `provider-api-docs` / `provider-api-request` | Use connected provider APIs with shared credentials; never request raw keys. |
 | `list-workspace-apps` / `update-workspace-app-metadata` | Inventory and edit mounted apps. |

package/corpus/templates/factory/actions/get-factory-graph-version.ts

@@ -0,0 +1,69 @@
+import { defineAction } from "@agent-native/core/action";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { factoryGraphVersions } from "../server/db/schema.js";
+import {
+  DEFAULT_FACTORY_ID,
+  parseFactoryGraph,
+  readFactoryDefinition,
+} from "../server/factory-graph/store.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+export default defineAction({
+  description:
+    "Read one validated Factory visual graph version for history preview. The snapshot is scoped to the active workspace and does not change the current Factory.",
+  schema: z.object({
+    factoryId: z
+      .string()
+      .trim()
+      .min(1)
+      .max(120)
+      .regex(/^[a-z0-9][a-z0-9-]*$/)
+      .default(DEFAULT_FACTORY_ID),
+    versionId: z.string().trim().min(1).max(240),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  parallelSafe: true,
+  run: async ({ factoryId, versionId }, context) => {
+    const { orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const currentDefinition = await readFactoryDefinition(orgId, factoryId);
+    const currentVersion = currentDefinition?.graphVersion ?? null;
+    const row = (
+      await getDb()
+        .select()
+        .from(factoryGraphVersions)
+        .where(
+          and(
+            eq(factoryGraphVersions.id, versionId),
+            eq(factoryGraphVersions.factoryId, factoryId),
+            eq(factoryGraphVersions.orgId, orgId),
+          ),
+        )
+        .limit(1)
+    )[0];
+
+    if (!row) {
+      throw new Error("Factory graph version not found.");
+    }
+
+    return {
+      id: row.id,
+      factoryId: row.factoryId,
+      version: row.version,
+      graph: parseFactoryGraph(row.graphJson),
+      source: row.source,
+      changeSummary: row.changeSummary,
+      createdAt: row.createdAt,
+      createdBy: row.createdBy,
+      isCurrent: currentVersion === row.version,
+    };
+  },
+});

package/corpus/templates/factory/actions/list-factory-graph-versions.ts

@@ -0,0 +1,82 @@
+import { defineAction } from "@agent-native/core/action";
+import { and, desc, eq, lt } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { factoryGraphVersions } from "../server/db/schema.js";
+import {
+  DEFAULT_FACTORY_ID,
+  readFactoryDefinition,
+} from "../server/factory-graph/store.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+export default defineAction({
+  description:
+    "List bounded saved visual graph version metadata for a Factory, newest first. Use get-factory-graph-version to read one validated snapshot for preview or restore.",
+  schema: z.object({
+    factoryId: z
+      .string()
+      .trim()
+      .min(1)
+      .max(120)
+      .regex(/^[a-z0-9][a-z0-9-]*$/)
+      .default(DEFAULT_FACTORY_ID),
+    limit: z.coerce.number().int().min(1).max(50).default(25),
+    beforeVersion: z.coerce.number().int().positive().optional(),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  parallelSafe: true,
+  run: async ({ factoryId, limit, beforeVersion }, context) => {
+    const { orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const currentDefinition = await readFactoryDefinition(orgId, factoryId);
+    const currentVersion = currentDefinition?.graphVersion ?? null;
+    const rows = await getDb()
+      .select({
+        id: factoryGraphVersions.id,
+        factoryId: factoryGraphVersions.factoryId,
+        version: factoryGraphVersions.version,
+        source: factoryGraphVersions.source,
+        changeSummary: factoryGraphVersions.changeSummary,
+        createdAt: factoryGraphVersions.createdAt,
+        createdBy: factoryGraphVersions.createdBy,
+      })
+      .from(factoryGraphVersions)
+      .where(
+        and(
+          eq(factoryGraphVersions.factoryId, factoryId),
+          eq(factoryGraphVersions.orgId, orgId),
+          beforeVersion === undefined
+            ? undefined
+            : lt(factoryGraphVersions.version, beforeVersion),
+        ),
+      )
+      .orderBy(desc(factoryGraphVersions.version))
+      .limit(limit + 1);
+    const page = rows.slice(0, limit);
+    const hasMore = rows.length > limit;
+
+    return {
+      factoryId,
+      currentVersion,
+      hasMore,
+      nextBeforeVersion:
+        hasMore && page.length > 0 ? page[page.length - 1].version : null,
+      versions: page.map((row) => ({
+        id: row.id,
+        factoryId: row.factoryId,
+        version: row.version,
+        source: row.source,
+        changeSummary: row.changeSummary,
+        createdAt: row.createdAt,
+        createdBy: row.createdBy,
+        isCurrent: currentVersion === row.version,
+      })),
+    };
+  },
+});

package/corpus/templates/factory/actions/restore-factory-graph-version.ts

@@ -0,0 +1,163 @@
+import { defineAction } from "@agent-native/core/action";
+import { buildDeepLink } from "@agent-native/core/server";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import {
+  factoryDefinitions,
+  factoryGraphVersions,
+} from "../server/db/schema.js";
+import { normalizeFactoryGraph } from "../server/factory-graph/contracts.js";
+import {
+  DEFAULT_FACTORY_ID,
+  parseFactoryGraph,
+} from "../server/factory-graph/store.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import { stableId } from "../server/triage/ids.js";
+
+export default defineAction({
+  description:
+    "Restore a Factory visual graph version. Restoring never deletes history: it validates the selected snapshot, appends it as a new version, and makes that new version current while preserving the Factory prompt.",
+  schema: z.object({
+    factoryId: z
+      .string()
+      .trim()
+      .min(1)
+      .max(120)
+      .regex(/^[a-z0-9][a-z0-9-]*$/)
+      .default(DEFAULT_FACTORY_ID),
+    versionId: z.string().trim().min(1).max(240),
+  }),
+  link: ({ result }) => ({
+    url: buildDeepLink({
+      app: "factory",
+      view: "factory",
+      params: { factoryId: result.factoryId, tab: "history" },
+    }),
+    label: `Open ${result.name} history in Factory`,
+  }),
+  run: async ({ factoryId, versionId }, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const db = getDb();
+
+    return db.transaction(async (tx) => {
+      const definition = (
+        await tx
+          .select()
+          .from(factoryDefinitions)
+          .where(
+            and(
+              eq(factoryDefinitions.id, factoryId),
+              eq(factoryDefinitions.orgId, orgId),
+            ),
+          )
+          .limit(1)
+      )[0];
+      if (!definition) {
+        throw new Error("Factory has no saved definition to restore.");
+      }
+
+      const version = (
+        await tx
+          .select()
+          .from(factoryGraphVersions)
+          .where(
+            and(
+              eq(factoryGraphVersions.id, versionId),
+              eq(factoryGraphVersions.factoryId, factoryId),
+              eq(factoryGraphVersions.orgId, orgId),
+            ),
+          )
+          .limit(1)
+      )[0];
+      if (!version) {
+        throw new Error("Factory graph version not found.");
+      }
+
+      const selectedGraph = parseFactoryGraph(version.graphJson);
+
+      if (version.version === definition.graphVersion) {
+        return {
+          ok: true,
+          alreadyCurrent: true,
+          factoryId,
+          versionId: version.id,
+          restoredFromVersion: version.version,
+          graphVersion: definition.graphVersion,
+          name: definition.name,
+          graph: selectedGraph,
+          source: "restore" as const,
+        };
+      }
+
+      const nextVersion = definition.graphVersion + 1;
+      const restoredGraph = normalizeFactoryGraph({
+        ...selectedGraph,
+        version: nextVersion,
+      });
+      const now = new Date().toISOString();
+      const nextVersionId = stableId(
+        "factory-graph",
+        orgId,
+        factoryId,
+        String(nextVersion),
+      );
+      const changeSummary = `Restored version ${version.version}.`;
+
+      const updated = await tx
+        .update(factoryDefinitions)
+        .set({
+          name: restoredGraph.name,
+          description: restoredGraph.description,
+          graphVersion: nextVersion,
+          graphJson: JSON.stringify(restoredGraph),
+          updatedAt: now,
+          ownerEmail: userEmail,
+        })
+        .where(
+          and(
+            eq(factoryDefinitions.id, factoryId),
+            eq(factoryDefinitions.orgId, orgId),
+            eq(factoryDefinitions.graphVersion, definition.graphVersion),
+          ),
+        )
+        .returning({ id: factoryDefinitions.id });
+      if (updated.length === 0) {
+        throw new Error(
+          "Factory changed while restoring. Refresh history and try again.",
+        );
+      }
+
+      await tx.insert(factoryGraphVersions).values({
+        id: nextVersionId,
+        factoryId,
+        version: nextVersion,
+        graphJson: JSON.stringify(restoredGraph),
+        source: "restore",
+        changeSummary,
+        createdAt: now,
+        createdBy: userEmail,
+        ownerEmail: userEmail,
+        orgId,
+      });
+
+      return {
+        ok: true,
+        alreadyCurrent: false,
+        factoryId,
+        versionId: nextVersionId,
+        restoredFromVersion: version.version,
+        graphVersion: nextVersion,
+        name: restoredGraph.name,
+        graph: restoredGraph,
+        source: "restore" as const,
+      };
+    });
+  },
+});