@agentprojectcontext/apx 1.80.2 → 1.89.1

package/src/core/integrations/catalog.js

@@ -8,16 +8,21 @@
 // + register it in PLUGIN_SERVICES (open/closed) — no API/route changes.
 //
 // Scope of this catalog (per product decision): Asana, GitHub, Obsidian,
-// WhatsApp. Telegram is intentionally absent — it's a channel, configured under
-// its own surface, not a service plugin. Transcription lives with the desktop
-// STT stack. Obsidian is path-based (a local Vault) rather than token-based.
+// Calendar, WhatsApp. Telegram is intentionally absent — it's a channel,
+// configured under its own surface, not a service plugin. Transcription lives
+// with the desktop STT stack. Obsidian is path-based (a local Vault) rather than
+// token-based, and Calendar is user-OAuth-based (auth: "oauth") — see
+// plugins/calendar.js for why it acts as you (invites + Meet) instead of as a
+// service account.
 import { asanaPlugin } from "./plugins/asana.js";
+import { calendarPlugin } from "./plugins/calendar.js";
 import { githubPlugin } from "./plugins/github.js";
 import { obsidianPlugin } from "./plugins/obsidian.js";
 
 // slug -> live plugin service (must implement the lifecycle contract).
 export const PLUGIN_SERVICES = Object.freeze({
   asana: asanaPlugin,
+  calendar: calendarPlugin,
   github: githubPlugin,
   obsidian: obsidianPlugin,
 });

package/src/core/integrations/plugins/_google-oauth.js

@@ -0,0 +1,179 @@
+// Google OAuth2 for user-delegated integrations (Calendar today).
+//
+// Why this exists — and why it replaced the service account:
+//
+// A service account acts as ITSELF. It can read a shared calendar and create
+// events on it, but Google blocks it from inviting other people or minting a
+// Meet link unless the whole account lives inside a Google Workspace domain
+// with Domain-Wide Delegation — a thing a personal @gmail.com simply does not
+// have. So "agendá una reunión con Carlos y mandale el Meet" was impossible.
+//
+// User OAuth acts AS YOU. You consent once in the browser, Google hands back a
+// refresh token, and from then on APX creates events, sends invitations, and
+// creates Meet links on your own calendar — because it is you doing it. The
+// price is a one-time OAuth client (client_id + secret) created in Google Cloud
+// Console, and that is the only console step left: no key file, no manual
+// calendar sharing, no Workspace.
+//
+// The flow: build a consent URL → the browser round-trips → Google redirects to
+// our callback with a `code` → we exchange it for a refresh token → we cache
+// short-lived access tokens in memory and refresh them as needed. ~1 file of
+// node:crypto + fetch, no Google SDK.
+import crypto from "node:crypto";
+
+export const AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+export const TOKEN_URL = "https://oauth2.googleapis.com/token";
+
+// The path Google redirects the browser back to. Kept scope/project-agnostic —
+// everything the callback needs travels in the signed `state`, so ONE redirect
+// URI is registered in the console and never changes. Mounted under /api by the
+// daemon (see api/prefix.js), so the full URL is `<origin>/api/integrations/oauth/callback`.
+export const CALLBACK_PATH = "/api/integrations/oauth/callback";
+
+/** The redirect URI to register in the console and to send on every exchange. */
+export function callbackUrl(origin) {
+  return `${String(origin || "").replace(/\/$/, "")}${CALLBACK_PATH}`;
+}
+
+// ─── state: signed, so the unauthenticated callback can't be forged ──────────
+//
+// The callback bypasses bearer auth (Google's browser redirect carries no
+// token), so anyone could hit it. We defend it by signing the `state` we put in
+// the consent URL with a per-process key: a callback whose state doesn't verify
+// is rejected. The key is ephemeral on purpose — a daemon restart invalidates
+// any consent link older than one boot, which is fine for a 10-minute flow.
+const STATE_KEY = crypto.randomBytes(32);
+const STATE_TTL_MS = 10 * 60_000;
+
+const b64url = (buf) =>
+  Buffer.from(buf).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+const b64urlJson = (obj) => b64url(JSON.stringify(obj));
+const fromB64url = (s) => Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64");
+
+/** Sign a small state payload (slug, pid, scope, origin) into an opaque token. */
+export function signState(payload) {
+  const body = b64urlJson({ ...payload, exp: Date.now() + STATE_TTL_MS });
+  const sig = b64url(crypto.createHmac("sha256", STATE_KEY).update(body).digest());
+  return `${body}.${sig}`;
+}
+
+/** Verify + decode a state token, or return null if forged/expired/malformed. */
+export function verifyState(token) {
+  const [body, sig] = String(token || "").split(".");
+  if (!body || !sig) return null;
+  const expected = b64url(crypto.createHmac("sha256", STATE_KEY).update(body).digest());
+  // Constant-time compare — the lengths match by construction (same HMAC).
+  if (sig.length !== expected.length || !crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected))) {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(fromB64url(body).toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (!data || typeof data.exp !== "number" || data.exp < Date.now()) return null;
+  return data;
+}
+
+// ─── consent URL ─────────────────────────────────────────────────────────────
+
+/**
+ * The URL to send the browser to. `access_type=offline` + `prompt=consent`
+ * guarantee a refresh token comes back every time (Google omits it on repeat
+ * consents otherwise, which would silently break reconnects).
+ */
+export function buildAuthUrl({ clientId, redirectUri, scope, state }) {
+  const u = new URL(AUTH_URL);
+  u.searchParams.set("client_id", clientId);
+  u.searchParams.set("redirect_uri", redirectUri);
+  u.searchParams.set("response_type", "code");
+  u.searchParams.set("scope", scope);
+  u.searchParams.set("access_type", "offline");
+  u.searchParams.set("prompt", "consent");
+  u.searchParams.set("include_granted_scopes", "true");
+  u.searchParams.set("state", state);
+  return u.toString();
+}
+
+// ─── token exchange + refresh ────────────────────────────────────────────────
+
+async function tokenRequest(params, { fetchImpl = fetch } = {}) {
+  const res = await fetchImpl(TOKEN_URL, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(params).toString(),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const detail = data.error_description || data.error || `HTTP ${res.status}`;
+    throw new Error(`Google rechazó el intercambio de token: ${detail}`);
+  }
+  return data;
+}
+
+/** First exchange: authorization code → { refresh_token, access_token, email }. */
+export async function exchangeCode({ clientId, clientSecret, code, redirectUri }, opts = {}) {
+  const data = await tokenRequest(
+    {
+      grant_type: "authorization_code",
+      code,
+      client_id: clientId,
+      client_secret: clientSecret,
+      redirect_uri: redirectUri,
+    },
+    opts,
+  );
+  if (!data.refresh_token) {
+    throw new Error(
+      "Google no devolvió un refresh token. Revocá el acceso de APX en myaccount.google.com/permissions y volvé a conectar (el flujo fuerza el consentimiento).",
+    );
+  }
+  return {
+    refresh_token: data.refresh_token,
+    access_token: data.access_token || null,
+    expires_in: Number(data.expires_in) || 3600,
+    email: emailFromIdToken(data.id_token),
+  };
+}
+
+// Access tokens last an hour and cost a round-trip; cache in memory keyed by the
+// refresh token, so several tool calls in one turn don't each re-mint one.
+const accessCache = new Map();
+
+export function clearAccessCache() {
+  accessCache.clear();
+}
+
+/** A valid access token for a refresh token, minted or served from cache. */
+export async function accessTokenFor({ clientId, clientSecret, refreshToken }, opts = {}) {
+  const hit = accessCache.get(refreshToken);
+  if (hit && hit.expires_at - 60_000 > Date.now()) return hit.access_token;
+  const data = await tokenRequest(
+    {
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: clientId,
+      client_secret: clientSecret,
+    },
+    opts,
+  );
+  if (!data.access_token) throw new Error("Google no devolvió un access token al refrescar.");
+  accessCache.set(refreshToken, {
+    access_token: data.access_token,
+    expires_at: Date.now() + (Number(data.expires_in) || 3600) * 1000,
+  });
+  return data.access_token;
+}
+
+/** Best-effort account email, decoded from the id_token payload (no verify). */
+export function emailFromIdToken(idToken) {
+  const seg = String(idToken || "").split(".")[1];
+  if (!seg) return null;
+  try {
+    const claims = JSON.parse(fromB64url(seg).toString("utf8"));
+    return claims.email || null;
+  } catch {
+    return null;
+  }
+}

package/src/core/integrations/plugins/asana.js

@@ -93,21 +93,25 @@ export async function listProjects(token, workspaceGid) {
 export async function listTasks(token, projectGid, completed = false) {
   const result = await request(token, "GET", `/projects/${projectGid}/tasks`, {
     params: {
-      opt_fields: "gid,name,completed,due_on,assignee.name,notes,permalink_url",
+      opt_fields: "gid,name,completed,due_on,assignee.name,notes,permalink_url,memberships.section.name,memberships.section.gid",
       completed_since: completed ? "" : "now",
     },
   });
   return result?.data || [];
 }
 
-export async function createTask(token, { workspaceGid, name, notes = "", projectGid, assignee, dueOn } = {}) {
+export async function createTask(token, { workspaceGid, name, notes = "", projectGid, sectionGid, assignee, dueOn } = {}) {
   const payload = { name, workspace: workspaceGid };
   if (notes) payload.notes = notes;
   if (projectGid) payload.projects = [projectGid];
   if (assignee) payload.assignee = assignee;
   if (dueOn) payload.due_on = dueOn;
   const result = await request(token, "POST", "/tasks", { payload });
-  return result?.data || {};
+  const task = result?.data || {};
+  if (sectionGid && task.gid) {
+    await request(token, "POST", `/sections/${sectionGid}/addTask`, { payload: { task: task.gid } });
+  }
+  return task;
 }
 
 export async function updateTask(token, taskGid, { name, notes, completed, dueOn, assignee } = {}) {

package/src/core/integrations/plugins/calendar.js

@@ -0,0 +1,404 @@
+// Google Calendar integration plugin — user OAuth, so an agent can act AS you.
+//
+// This plugin used to authenticate with a service account: paste a JSON key,
+// share your calendar with a robot email, done. It worked for reading and for
+// creating plain events, but a service account acts as ITSELF, and Google bars
+// it from inviting other people or creating a Meet link without Domain-Wide
+// Delegation — a Workspace feature a personal @gmail.com does not have. So
+// "agendá con Carlos y mandale el Meet" was simply impossible.
+//
+// User OAuth acts as YOU. You consent once in the browser and Google hands back
+// a refresh token; from then on APX reads your agenda, creates and moves events,
+// SENDS INVITATIONS, and creates Meet links — because it is you doing it, on your
+// own calendar. The only setup left is a one-time OAuth client in Google Cloud
+// Console (client_id + secret). No key file, no calendar sharing, no Workspace.
+//
+// The OAuth mechanics (consent URL, code exchange, refresh, state signing) live
+// in ./_google-oauth.js. This file is the calendar REST client + the plugin
+// lifecycle the daemon and web panel drive.
+import crypto from "node:crypto";
+import {
+  buildAuthUrl,
+  callbackUrl,
+  signState,
+  exchangeCode,
+  accessTokenFor,
+} from "./_google-oauth.js";
+
+const API = "https://www.googleapis.com/calendar/v3";
+
+// Full calendar when the owner allows writes (create/move events, invite people,
+// mint Meet links, free/busy); read-only otherwise. `openid email` rides along
+// so we can show which account is connected. Kept broad-but-standard on purpose:
+// narrower per-feature scopes make invites and free/busy fragile for no real gain
+// on a single-user tool.
+export const SCOPE_READ = "openid email https://www.googleapis.com/auth/calendar.readonly";
+export const SCOPE_WRITE = "openid email https://www.googleapis.com/auth/calendar";
+
+function scopeFor(config) {
+  return config?.write_access ? SCOPE_WRITE : SCOPE_READ;
+}
+
+// ─── access tokens ────────────────────────────────────────────────────────────
+
+/** A live access token for the stored connection, or a clear error. */
+export async function getAccessToken(config = {}, opts = {}) {
+  const { client_id, client_secret, refresh_token } = config || {};
+  if (!client_id || !client_secret) {
+    throw new Error("Falta el OAuth client (client_id / client_secret). Cargalos en el panel.");
+  }
+  if (!refresh_token) {
+    throw new Error("El calendario no está autorizado todavía. Conectá con Google en el panel.");
+  }
+  return accessTokenFor({ clientId: client_id, clientSecret: client_secret, refreshToken: refresh_token }, opts);
+}
+
+// ─── REST client ────────────────────────────────────────────────────────────
+
+async function call(config, urlPath, { method = "GET", query, body, fetchImpl = fetch } = {}) {
+  const token = await getAccessToken(config, { fetchImpl });
+  const url = new URL(API + urlPath);
+  for (const [k, v] of Object.entries(query || {})) {
+    if (v !== undefined && v !== null && v !== "") url.searchParams.set(k, String(v));
+  }
+  const res = await fetchImpl(url.toString(), {
+    method,
+    headers: {
+      authorization: `Bearer ${token}`,
+      ...(body ? { "content-type": "application/json" } : {}),
+    },
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  });
+
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const msg = data?.error?.message || `HTTP ${res.status}`;
+    if (res.status === 401 || res.status === 403) {
+      throw new Error(`${msg} — puede que haga falta reconectar con Google en el panel.`);
+    }
+    throw new Error(msg);
+  }
+  return data;
+}
+
+/** Calendars the connected account can see — used only for the account probe. */
+export async function listCalendars(config, opts = {}) {
+  const data = await call(config, "/users/me/calendarList", { ...opts });
+  return (data.items || []).map((c) => ({
+    id: c.id,
+    summary: c.summary || c.id,
+    timeZone: c.timeZone || null,
+    accessRole: c.accessRole || null,
+    primary: !!c.primary,
+  }));
+}
+
+/** One event, flattened to what a prompt actually needs. */
+function flattenEvent(e) {
+  return {
+    id: e.id,
+    title: e.summary || "(sin título)",
+    start: e.start?.dateTime || e.start?.date || null,
+    end: e.end?.dateTime || e.end?.date || null,
+    all_day: !!e.start?.date,
+    location: e.location || null,
+    attendees: (e.attendees || []).map((a) => a.email).filter(Boolean),
+    status: e.status || null,
+    link: e.htmlLink || null,
+    meet_link: e.hangoutLink || null,
+  };
+}
+
+export async function listEvents(config, { calendarId = "primary", timeMin, timeMax, q, maxResults = 25 } = {}, opts = {}) {
+  const data = await call(config, `/calendars/${encodeURIComponent(calendarId)}/events`, {
+    query: { timeMin, timeMax, q, maxResults, singleEvents: true, orderBy: "startTime" },
+    ...opts,
+  });
+  return (data.items || []).map(flattenEvent);
+}
+
+/**
+ * Create an event. Because we act as the user now, two things that were
+ * impossible with a service account just work:
+ *   - attendees get a real invitation (`sendUpdates=all`)
+ *   - `meet: true` mints a Google Meet link (`conferenceData` + v1)
+ */
+export async function createEvent(
+  config,
+  { calendarId = "primary", title, start, end, description, location, attendees, meet = false } = {},
+  opts = {},
+) {
+  const hasAttendees = Array.isArray(attendees) && attendees.length > 0;
+  const body = {
+    summary: title,
+    description: description || undefined,
+    location: location || undefined,
+    start: { dateTime: start },
+    end: { dateTime: end },
+    ...(hasAttendees ? { attendees: attendees.map((email) => ({ email })) } : {}),
+    ...(meet
+      ? {
+          conferenceData: {
+            createRequest: {
+              requestId: crypto.randomUUID(),
+              conferenceSolutionKey: { type: "hangoutsMeet" },
+            },
+          },
+        }
+      : {}),
+  };
+  const data = await call(config, `/calendars/${encodeURIComponent(calendarId)}/events`, {
+    method: "POST",
+    body,
+    query: {
+      ...(meet ? { conferenceDataVersion: 1 } : {}),
+      ...(hasAttendees ? { sendUpdates: "all" } : {}),
+    },
+    ...opts,
+  });
+  return flattenEvent(data);
+}
+
+export async function updateEvent(config, { calendarId = "primary", eventId, ...fields } = {}, opts = {}) {
+  const body = {};
+  if (fields.title !== undefined) body.summary = fields.title;
+  if (fields.description !== undefined) body.description = fields.description;
+  if (fields.location !== undefined) body.location = fields.location;
+  if (fields.start !== undefined) body.start = { dateTime: fields.start };
+  if (fields.end !== undefined) body.end = { dateTime: fields.end };
+  const hasAttendees = Array.isArray(fields.attendees) && fields.attendees.length > 0;
+  if (fields.attendees !== undefined) body.attendees = (fields.attendees || []).map((email) => ({ email }));
+  const data = await call(config, `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`, {
+    method: "PATCH",
+    body,
+    query: { ...(hasAttendees ? { sendUpdates: "all" } : {}) },
+    ...opts,
+  });
+  return flattenEvent(data);
+}
+
+/**
+ * The first gaps of at least `minutes` between timeMin and timeMax, from
+ * Google's freeBusy view. Pure arithmetic once the busy blocks are in.
+ */
+export async function findSlots(config, { calendarId = "primary", timeMin, timeMax, minutes = 30, limit = 5 } = {}, opts = {}) {
+  const token = await getAccessToken(config, opts);
+  const fetchImpl = opts.fetchImpl || fetch;
+  const res = await fetchImpl(`${API}/freeBusy`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+    body: JSON.stringify({ timeMin, timeMax, items: [{ id: calendarId }] }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data?.error?.message || `HTTP ${res.status}`);
+
+  const busy = (data.calendars?.[calendarId]?.busy || [])
+    .map((b) => [Date.parse(b.start), Date.parse(b.end)])
+    .filter(([s, e]) => Number.isFinite(s) && Number.isFinite(e))
+    .sort((a, b) => a[0] - b[0]);
+
+  const needed = minutes * 60_000;
+  const slots = [];
+  let cursor = Date.parse(timeMin);
+  const end = Date.parse(timeMax);
+
+  for (const [bStart, bEnd] of busy) {
+    if (bStart - cursor >= needed) {
+      slots.push({ start: new Date(cursor).toISOString(), end: new Date(bStart).toISOString() });
+      if (slots.length >= limit) return slots;
+    }
+    cursor = Math.max(cursor, bEnd);
+  }
+  if (end - cursor >= needed) {
+    slots.push({ start: new Date(cursor).toISOString(), end: new Date(end).toISOString() });
+  }
+  return slots.slice(0, limit);
+}
+
+// ─── plugin lifecycle ───────────────────────────────────────────────────────
+
+function asBool(v, fallback = false) {
+  if (v === undefined || v === null) return fallback;
+  return v === true || v === "true" || v === "on" || v === 1 || v === "1";
+}
+
+export const calendarPlugin = {
+  slug: "calendar",
+  name: "Google Calendar",
+  type: "calendar",
+  description:
+    "Conectá tu Google Calendar con OAuth para que los agentes lean tu agenda, agenden, inviten y armen Meet",
+  auth: "oauth",
+  tools: [
+    { slug: "calendar_list_events", desc: "Ver qué hay en la agenda" },
+    { slug: "calendar_find_slot", desc: "Buscar huecos libres" },
+    { slug: "calendar_create_event", desc: "Agendar un evento (con invitados y Meet)" },
+    { slug: "calendar_update_event", desc: "Mover o editar un evento" },
+  ],
+  // Structure only — display text lives in web i18n (integrations.calendar.*).
+  ui: {
+    accent: "sky",
+    // Presence of `oauth` tells the web component to run the consent flow:
+    // save client_id/secret, then a "Conectar con Google" button. `redirectPath`
+    // is the URI the user registers in the console (shown in the UI).
+    oauth: { action: "authorize", redirectPath: "/api/integrations/oauth/callback" },
+    configFields: [
+      {
+        key: "client_id",
+        type: "text",
+        placeholder: "123-abc.apps.googleusercontent.com",
+        help_url: "https://console.cloud.google.com/apis/credentials",
+        help_url_label: "console.cloud.google.com",
+      },
+      { key: "client_secret", type: "password", placeholder: "GOCSPX-…" },
+      { key: "write_access", type: "toggle", default: true },
+      { key: "meet", type: "toggle", default: true },
+    ],
+    connectedFields: ["account_email", "calendar_name"],
+  },
+
+  // Save the OAuth client + preferences. This never mints tokens — authorization
+  // happens in the browser (authorize action → callback → completeOAuth).
+  configure(record, body = {}) {
+    const prev = record?.config || {};
+    const clientId = String(body.client_id ?? prev.client_id ?? "").trim();
+    const clientSecret = String(body.client_secret ?? prev.client_secret ?? "").trim();
+
+    // A live connection flipping a preference (write/meet) shouldn't need the
+    // secret re-typed — merge over what's stored.
+    const config = {
+      ...(clientId ? { client_id: clientId } : {}),
+      ...(clientSecret ? { client_secret: clientSecret } : {}),
+      write_access: asBool(body.write_access, prev.write_access ?? true),
+      meet: asBool(body.meet, prev.meet ?? true),
+    };
+
+    if (!clientId && !prev.client_id) {
+      throw new Error("Cargá el client_id del OAuth client de Google.");
+    }
+
+    const patch = { name: this.name, type: this.type, description: this.description, config };
+    // A changed write scope needs a re-consent (the granted scope no longer
+    // matches). Everything else keeps the current connection.
+    if (config.write_access !== prev.write_access && prev.refresh_token) {
+      patch.status = "pending_validation";
+      patch.config.needs_reauth = true;
+    }
+    return { patch };
+  },
+
+  /**
+   * Build the Google consent URL. Called by the web panel (authorize action);
+   * `ctx.origin` is the browser origin, so the redirect URI matches what the
+   * user registered and what the callback reconstructs.
+   */
+  buildAuthorizeUrl(record, { origin, pid, scope } = {}) {
+    const config = record?.config || {};
+    if (!config.client_id) throw new Error("Cargá primero el client_id.");
+    if (!origin) throw new Error("No pude determinar el origin del panel para el redirect.");
+    const redirectUri = callbackUrl(origin);
+    const state = signState({ slug: this.slug, pid: String(pid ?? ""), scope: scope || "project" });
+    const auth_url = buildAuthUrl({
+      clientId: config.client_id,
+      redirectUri,
+      scope: scopeFor(config),
+      state,
+    });
+    return { auth_url, redirect_uri: redirectUri };
+  },
+
+  /**
+   * Finish the OAuth dance: trade the code for a refresh token and activate.
+   * Called by the daemon's callback route. Returns a patch to persist.
+   */
+  async completeOAuth(record, { code, redirectUri } = {}) {
+    const config = record?.config || {};
+    if (!config.client_id || !config.client_secret) {
+      throw new Error("Falta el OAuth client guardado para completar la conexión.");
+    }
+    const tokens = await exchangeCode({
+      clientId: config.client_id,
+      clientSecret: config.client_secret,
+      code,
+      redirectUri,
+    });
+    return {
+      patch: {
+        status: "active",
+        is_enabled: true,
+        config: {
+          refresh_token: tokens.refresh_token,
+          account_email: tokens.email || config.account_email || null,
+          calendar_id: "primary",
+          calendar_name: tokens.email || "primary",
+          needs_reauth: false,
+          last_error: null,
+        },
+      },
+    };
+  },
+
+  // Re-check a stored connection (used when flipping toggles once connected).
+  async validate(record) {
+    const config = record?.config || {};
+    if (!config.refresh_token) {
+      const detail = "Autorizá con Google en el panel para conectar el calendario.";
+      return {
+        patch: { status: "pending_validation", is_enabled: false, config: { last_error: detail } },
+        result: { ok: false, error: detail, needs_auth: true },
+      };
+    }
+    try {
+      // A cheap call that proves the refresh token still works.
+      await call(config, "/users/me/calendarList", { query: { maxResults: 1 } });
+    } catch (e) {
+      return {
+        patch: { status: "error", is_enabled: false, config: { last_error: String(e.message || e) } },
+        result: { ok: false, error: String(e.message || e) },
+      };
+    }
+    return {
+      patch: { status: "active", is_enabled: true, config: { calendar_id: "primary", needs_reauth: false, last_error: null } },
+      result: { ok: true, account_email: config.account_email || null },
+    };
+  },
+
+  status(record) {
+    const c = record?.config || {};
+    // No refresh token → not connected, whatever the stored status says. This
+    // also demotes a leftover service-account record from the old auth model so
+    // it can't masquerade as "active" after the OAuth migration.
+    const authorized = !!c.refresh_token;
+    let st = record?.status || "disconnected";
+    if (!authorized && st === "active") st = "disconnected";
+    return {
+      slug: this.slug,
+      status: st,
+      is_enabled: authorized && !!record?.is_enabled,
+      account_email: c.account_email || null,
+      calendar_id: c.calendar_id || (c.refresh_token ? "primary" : null),
+      calendar_name: c.calendar_name || (c.refresh_token ? c.account_email || "primary" : null),
+      write_access: !!c.write_access,
+      meet: !!c.meet,
+      client_id_set: !!c.client_id,
+      needs_reauth: !!c.needs_reauth,
+    };
+  },
+
+  deactivate() {
+    return { patch: { status: "inactive", is_enabled: false } };
+  },
+
+  actions: {
+    // Kick off OAuth: the web panel opens the returned auth_url in a popup.
+    async authorize(record, ctx = {}) {
+      return calendarPlugin.buildAuthorizeUrl(record, {
+        origin: ctx.origin,
+        pid: ctx.project?.id ?? 0,
+        scope: ctx.scope,
+      });
+    },
+  },
+};
+
+export default calendarPlugin;

package/src/core/integrations/store.js

@@ -14,6 +14,8 @@ const SECRET_KEYS = new Set([
   "token",
   "api_key",
   "client_secret",
+  "refresh_token",
+  "access_token",
 ]);
 
 // Return a shallow copy of a record with secret config values masked, safe to

package/src/core/memory/broker.js

@@ -73,6 +73,21 @@ function lastMemoryEntries(memoryPath, n) {
   }
 }
 
+// A recalled tool row is indexed as `[tool result: <name>] <name>({…args})`.
+// Stripping the prefix — which is what this did — left the bare call shape
+// sitting in the prompt, the exact worked example that teaches a model to
+// WRITE calls instead of making them (see tools/tool-call-parser.js). The
+// name and the arguments are what makes the bullet useful; the parentheses
+// and braces are what makes it dangerous, so only those go.
+function deFangToolRow(text) {
+  const m = String(text ?? "").match(/^\[tool result:\s*([^\]\n]+)\]\s*([\s\S]*)$/);
+  if (!m) return text;
+  const name = m[1].trim();
+  let body = m[2].trim();
+  if (body.startsWith(`${name}(`) && body.endsWith(")")) body = body.slice(name.length + 1, -1);
+  return `${name} → ${body.replace(/[{}]/g, "")}`.trim();
+}
+
 function bulletFor({ date, channel, text }) {
   const d = date ? `[${date}]` : "";
   const c = channel && channel !== "memory" ? `[${channel}]` : channel === "memory" ? "[memory]" : "";
@@ -129,7 +144,7 @@ export async function buildMemoryBlock(message, opts = {}) {
     push({
       date: dateOf(h.ts),
       channel: h.tag === "memory" ? "memory" : h.channel,
-      text: h.text.replace(/^\[tool result: [^\]]+\]\s*/, ""),
+      text: deFangToolRow(h.text),
     });
   }
   for (const e of memEntries) {