@neuroverseos/governance 0.10.0 → 0.12.0

package/dist/radiant/index.cjs

@@ -56,16 +56,20 @@ __export(radiant_exports, {
   fetchDiscordActivity: () => fetchDiscordActivity,
   fetchGitHubActivity: () => fetchGitHubActivity,
   fetchGitHubOrgActivity: () => fetchGitHubOrgActivity,
+  fetchGoogleWorkspaceActivity: () => fetchGoogleWorkspaceActivity,
   fetchLinearActivity: () => fetchLinearActivity,
   fetchNotionActivity: () => fetchNotionActivity,
+  fetchSalesforceActivity: () => fetchSalesforceActivity,
   fetchSlackActivity: () => fetchSlackActivity,
   filterEventsByUser: () => filterEventsByUser,
   formatActiveWorlds: () => formatActiveWorlds,
   formatDiscordSignalsForPrompt: () => formatDiscordSignalsForPrompt,
   formatExocortexForPrompt: () => formatExocortexForPrompt,
+  formatGoogleWorkspaceSignalsForPrompt: () => formatGoogleWorkspaceSignalsForPrompt,
   formatLinearSignalsForPrompt: () => formatLinearSignalsForPrompt,
   formatNotionSignalsForPrompt: () => formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt: () => formatPriorReadsForPrompt,
+  formatSalesforceSignalsForPrompt: () => formatSalesforceSignalsForPrompt,
   formatScope: () => formatScope,
   formatSlackSignalsForPrompt: () => formatSlackSignalsForPrompt,
   formatTeamExocorticesForPrompt: () => formatTeamExocorticesForPrompt,
@@ -2296,6 +2300,405 @@ async function fetchLinearGraphQL(apiKey, query, variables) {
   return json.data;
 }
 
+// src/radiant/adapters/google-workspace.ts
+async function fetchGoogleWorkspaceActivity(options) {
+  const windowDays = options.windowDays ?? 14;
+  const maxEmails = options.maxEmails ?? 100;
+  const maxEvents = options.maxEvents ?? 100;
+  const leaderEmail = options.leaderEmail?.toLowerCase();
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const [emailEvents, emailSignals] = await fetchGmailSent(
+    options.accessToken,
+    since,
+    maxEmails,
+    leaderEmail
+  );
+  const [calendarEvents, calendarSignals] = await fetchCalendarEvents(
+    options.accessToken,
+    since,
+    maxEvents,
+    leaderEmail
+  );
+  const events = [...emailEvents, ...calendarEvents].sort(
+    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)
+  );
+  return {
+    events,
+    signals: {
+      ...emailSignals,
+      ...calendarSignals
+    }
+  };
+}
+function formatGoogleWorkspaceSignalsForPrompt(signals) {
+  if (signals.emailsSent === 0 && signals.meetingsHeld === 0) return "";
+  const lines = [
+    "## Google Workspace Activity (external coordination + meeting load)",
+    ""
+  ];
+  if (signals.emailsSent > 0) {
+    lines.push(
+      `${signals.emailsSent} emails sent in window, to ${signals.uniqueRecipients} unique recipients.`
+    );
+    if (signals.topRecipients.length > 0) {
+      lines.push(`Most-emailed: ${signals.topRecipients.slice(0, 5).join(", ")}.`);
+    }
+  }
+  if (signals.meetingsHeld > 0) {
+    const hours = Math.round(signals.totalMeetingMinutes / 60 * 10) / 10;
+    lines.push(
+      `${signals.meetingsHeld} meetings held (${signals.meetingsOrganized} organized by the leader), ${hours}h total.`
+    );
+    if (signals.avgMeetingAttendees !== null) {
+      lines.push(
+        `Average ${signals.avgMeetingAttendees} attendees per meeting, ${signals.uniqueAttendees} unique attendees total.`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(
+    "Gmail sent volume + Calendar meeting load reveal a leader's external coordination shape."
+  );
+  lines.push(
+    "Compare against shipped work (GitHub, Linear) to find the stated-strategy-vs-actual-time gap."
+  );
+  return lines.join("\n");
+}
+async function fetchGmailSent(token, since, maxEmails, leaderEmail) {
+  const sinceUnix = Math.floor(since.getTime() / 1e3);
+  const listUrl = new URL("https://gmail.googleapis.com/gmail/v1/users/me/messages");
+  listUrl.searchParams.set("q", `in:sent after:${sinceUnix}`);
+  listUrl.searchParams.set("maxResults", String(Math.min(maxEmails, 100)));
+  const listRes = await fetch(listUrl.toString(), {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!listRes.ok) {
+    throw new Error(`Gmail list failed ${listRes.status}: ${(await listRes.text()).slice(0, 200)}`);
+  }
+  const listJson = await listRes.json();
+  const ids = (listJson.messages ?? []).slice(0, maxEmails);
+  const events = [];
+  const recipientCounts = /* @__PURE__ */ new Map();
+  const PARALLEL = 5;
+  for (let i = 0; i < ids.length; i += PARALLEL) {
+    const chunk = ids.slice(i, i + PARALLEL);
+    const results = await Promise.all(
+      chunk.map(
+        (m) => fetch(
+          `https://gmail.googleapis.com/gmail/v1/users/me/messages/${m.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`,
+          { headers: { Authorization: `Bearer ${token}` } }
+        ).then((r) => r.ok ? r.json() : null).catch(() => null)
+      )
+    );
+    for (const msg of results) {
+      if (!msg) continue;
+      const headers = msg.payload?.headers || [];
+      const header = (n) => headers.find((h) => h.name.toLowerCase() === n.toLowerCase())?.value ?? "";
+      const subject = header("Subject") || "(no subject)";
+      const to = header("To");
+      const dateHdr = header("Date");
+      const timestamp = dateHdr ? new Date(dateHdr).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      const snippet = msg.snippet ?? "";
+      const recipients = parseAddressList(to);
+      for (const r of recipients) {
+        recipientCounts.set(r, (recipientCounts.get(r) ?? 0) + 1);
+      }
+      events.push({
+        id: `gmail-${msg.id}`,
+        timestamp,
+        actor: {
+          id: leaderEmail ?? "leader",
+          kind: "human",
+          name: leaderEmail ?? "Leader"
+        },
+        kind: "email_sent",
+        content: `${subject} \u2014 ${snippet.slice(0, 200)}`,
+        metadata: {
+          to: recipients.slice(0, 5),
+          subject
+        }
+      });
+    }
+  }
+  const topRecipients = [...recipientCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([addr]) => addr);
+  return [
+    events,
+    {
+      emailsSent: events.length,
+      uniqueRecipients: recipientCounts.size,
+      topRecipients
+    }
+  ];
+}
+function parseAddressList(raw) {
+  if (!raw) return [];
+  return raw.split(",").map((a) => {
+    const match = a.match(/<([^>]+)>/);
+    const addr = (match ? match[1] : a).trim().toLowerCase();
+    return addr;
+  }).filter((a) => a.includes("@") && a.length < 100);
+}
+async function fetchCalendarEvents(token, since, maxEvents, leaderEmail) {
+  const timeMin = since.toISOString();
+  const timeMax = (/* @__PURE__ */ new Date()).toISOString();
+  const url = new URL("https://www.googleapis.com/calendar/v3/calendars/primary/events");
+  url.searchParams.set("timeMin", timeMin);
+  url.searchParams.set("timeMax", timeMax);
+  url.searchParams.set("singleEvents", "true");
+  url.searchParams.set("orderBy", "startTime");
+  url.searchParams.set("maxResults", String(Math.min(maxEvents, 250)));
+  const res = await fetch(url.toString(), {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Calendar list failed ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  }
+  const json = await res.json();
+  const events = [];
+  const attendeeSet = /* @__PURE__ */ new Set();
+  let totalMinutes = 0;
+  let meetingsOrganized = 0;
+  const attendeeCounts = [];
+  for (const ev of json.items ?? []) {
+    if (ev.status === "cancelled") continue;
+    const start = ev.start?.dateTime || ev.start?.date;
+    const end = ev.end?.dateTime || ev.end?.date;
+    if (!start) continue;
+    const startMs = new Date(start).getTime();
+    const endMs = end ? new Date(end).getTime() : startMs;
+    const minutes = Math.max(0, Math.round((endMs - startMs) / 6e4));
+    totalMinutes += minutes;
+    const attendees = (ev.attendees ?? []).map((a) => a.email?.toLowerCase()).filter((e) => !!e && e.includes("@"));
+    for (const a of attendees) attendeeSet.add(a);
+    attendeeCounts.push(attendees.length);
+    const organizedByLeader = leaderEmail && ev.organizer?.email?.toLowerCase() === leaderEmail;
+    if (organizedByLeader) meetingsOrganized++;
+    events.push({
+      id: `gcal-${ev.id}`,
+      timestamp: start,
+      actor: {
+        id: leaderEmail ?? "leader",
+        kind: "human",
+        name: leaderEmail ?? "Leader"
+      },
+      kind: organizedByLeader ? "meeting_organized" : "meeting_attended",
+      content: `${ev.summary ?? "(no title)"} \u2014 ${minutes}min, ${attendees.length} attendees`,
+      metadata: {
+        attendees: attendees.slice(0, 10),
+        minutes,
+        organizer: ev.organizer?.email
+      }
+    });
+  }
+  const avgAttendees = attendeeCounts.length > 0 ? Math.round(
+    attendeeCounts.reduce((a, b) => a + b, 0) / attendeeCounts.length
+  ) : null;
+  return [
+    events,
+    {
+      meetingsHeld: events.length,
+      meetingsOrganized,
+      uniqueAttendees: attendeeSet.size,
+      totalMeetingMinutes: totalMinutes,
+      avgMeetingAttendees: avgAttendees
+    }
+  ];
+}
+
+// src/radiant/adapters/salesforce.ts
+async function fetchSalesforceActivity(options) {
+  const windowDays = options.windowDays ?? 14;
+  const maxRecords = Math.min(options.maxRecords ?? 200, 200);
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const sinceSoql = since.toISOString();
+  const events = [];
+  const signals = {
+    opportunitiesMoved: 0,
+    stageTransitions: 0,
+    amountChanges: 0,
+    closedWon: 0,
+    closedLost: 0,
+    tasksLogged: 0,
+    callsLogged: 0,
+    feedPostsByLeader: 0,
+    totalPipelineAmount: 0,
+    topStages: []
+  };
+  const opps = await soqlQuery(
+    options,
+    `SELECT Id, Name, StageName, Amount, CloseDate, IsClosed, IsWon, LastModifiedDate, Owner.Name
+     FROM Opportunity
+     WHERE LastModifiedDate >= ${sinceSoql}
+     ORDER BY LastModifiedDate DESC
+     LIMIT ${maxRecords}`
+  );
+  const stageCounts = /* @__PURE__ */ new Map();
+  for (const opp of opps) {
+    signals.opportunitiesMoved++;
+    signals.totalPipelineAmount += opp.Amount ?? 0;
+    stageCounts.set(opp.StageName, (stageCounts.get(opp.StageName) ?? 0) + 1);
+    if (opp.IsClosed && opp.IsWon) signals.closedWon++;
+    if (opp.IsClosed && !opp.IsWon) signals.closedLost++;
+    events.push({
+      id: `sf-opp-${opp.Id}`,
+      timestamp: opp.LastModifiedDate,
+      actor: {
+        id: opp.Owner?.Name ?? "unknown",
+        kind: "human",
+        name: opp.Owner?.Name ?? "unknown"
+      },
+      kind: opp.IsClosed ? opp.IsWon ? "deal_won" : "deal_lost" : "deal_updated",
+      content: `${opp.Name} \u2014 ${opp.StageName}${opp.Amount ? ` \xB7 $${Math.round(opp.Amount).toLocaleString()}` : ""} \xB7 close ${opp.CloseDate}`,
+      metadata: {
+        opportunityId: opp.Id,
+        stage: opp.StageName,
+        amount: opp.Amount,
+        closeDate: opp.CloseDate
+      }
+    });
+  }
+  signals.topStages = [...stageCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([stage, count]) => ({ stage, count }));
+  const history = await soqlQuery(
+    options,
+    `SELECT Id, OpportunityId, Field, OldValue, NewValue, CreatedDate, CreatedBy.Name
+     FROM OpportunityFieldHistory
+     WHERE CreatedDate >= ${sinceSoql} AND Field IN ('StageName', 'Amount', 'CloseDate')
+     ORDER BY CreatedDate DESC
+     LIMIT ${maxRecords}`
+  ).catch(() => []);
+  for (const h of history) {
+    if (h.Field === "StageName") signals.stageTransitions++;
+    if (h.Field === "Amount") signals.amountChanges++;
+    events.push({
+      id: `sf-hist-${h.Id}`,
+      timestamp: h.CreatedDate,
+      actor: {
+        id: h.CreatedBy?.Name ?? "unknown",
+        kind: "human",
+        name: h.CreatedBy?.Name ?? "unknown"
+      },
+      kind: `deal_${h.Field.toLowerCase()}_changed`,
+      content: `${h.Field}: ${String(h.OldValue)} \u2192 ${String(h.NewValue)}`,
+      metadata: {
+        opportunityId: h.OpportunityId,
+        field: h.Field
+      }
+    });
+  }
+  const tasks = await soqlQuery(
+    options,
+    `SELECT Id, Subject, Status, Type, CreatedDate, Owner.Name
+     FROM Task
+     WHERE CreatedDate >= ${sinceSoql}
+     ORDER BY CreatedDate DESC
+     LIMIT ${maxRecords}`
+  ).catch(() => []);
+  for (const t of tasks) {
+    signals.tasksLogged++;
+    if (t.Type === "Call" || (t.Subject || "").toLowerCase().includes("call")) {
+      signals.callsLogged++;
+    }
+    events.push({
+      id: `sf-task-${t.Id}`,
+      timestamp: t.CreatedDate,
+      actor: {
+        id: t.Owner?.Name ?? "unknown",
+        kind: "human",
+        name: t.Owner?.Name ?? "unknown"
+      },
+      kind: t.Type === "Call" ? "call_logged" : "task_logged",
+      content: `${t.Subject} \u2014 ${t.Status}`,
+      metadata: { taskId: t.Id, type: t.Type, status: t.Status }
+    });
+  }
+  if (options.leaderName) {
+    const feed = await soqlQuery(
+      options,
+      `SELECT Id, Body, CreatedDate, CreatedBy.Name, ParentId
+       FROM FeedItem
+       WHERE CreatedDate >= ${sinceSoql} AND CreatedBy.Name = '${escapeSoql(options.leaderName)}'
+       ORDER BY CreatedDate DESC
+       LIMIT ${Math.min(maxRecords, 50)}`
+    ).catch(() => []);
+    for (const f of feed) {
+      signals.feedPostsByLeader++;
+      events.push({
+        id: `sf-feed-${f.Id}`,
+        timestamp: f.CreatedDate,
+        actor: {
+          id: f.CreatedBy?.Name ?? "unknown",
+          kind: "human",
+          name: f.CreatedBy?.Name ?? "unknown"
+        },
+        kind: "feed_post",
+        content: (f.Body || "").slice(0, 280),
+        metadata: { feedId: f.Id, parent: f.ParentId }
+      });
+    }
+  }
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatSalesforceSignalsForPrompt(signals) {
+  if (signals.opportunitiesMoved === 0 && signals.tasksLogged === 0 && signals.stageTransitions === 0) {
+    return "";
+  }
+  const lines = [
+    "## Salesforce Activity (stated pipeline vs observed motion)",
+    ""
+  ];
+  if (signals.opportunitiesMoved > 0) {
+    const pipelineM = Math.round(signals.totalPipelineAmount / 1e4) / 100;
+    lines.push(
+      `${signals.opportunitiesMoved} opportunities touched in window ($${pipelineM}M total pipeline represented).`
+    );
+    lines.push(
+      `${signals.stageTransitions} stage changes, ${signals.amountChanges} amount changes.`
+    );
+    if (signals.closedWon + signals.closedLost > 0) {
+      lines.push(`${signals.closedWon} closed won, ${signals.closedLost} closed lost.`);
+    }
+    if (signals.topStages.length > 0) {
+      lines.push(
+        `Most active stages: ${signals.topStages.map((s) => `${s.stage} (${s.count})`).join(", ")}.`
+      );
+    }
+  }
+  if (signals.tasksLogged > 0) {
+    lines.push(
+      `${signals.tasksLogged} tasks logged (${signals.callsLogged} calls).`
+    );
+  }
+  if (signals.feedPostsByLeader > 0) {
+    lines.push(`${signals.feedPostsByLeader} feed posts by the leader.`);
+  }
+  lines.push("");
+  lines.push(
+    "Salesforce shows what the team said would happen (stages, forecast) vs. what is actually happening (movement, activity, close)."
+  );
+  lines.push(
+    "Compare stage transitions against stated strategy \u2014 are the deals the leader said would close actually moving, or is the pipeline drifting?"
+  );
+  return lines.join("\n");
+}
+async function soqlQuery(opts, query) {
+  const url = new URL(`${opts.instanceUrl}/services/data/v59.0/query`);
+  url.searchParams.set("q", query);
+  const res = await fetch(url.toString(), {
+    headers: { Authorization: `Bearer ${opts.accessToken}` }
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Salesforce SOQL ${res.status}: ${(await res.text()).slice(0, 200)}`
+    );
+  }
+  const json = await res.json();
+  return json.records ?? [];
+}
+function escapeSoql(raw) {
+  return raw.replace(/['\\]/g, "");
+}
+
 // src/radiant/core/vocabulary.ts
 function extractDeclaredVocabulary(worldmodelContent) {
   const aligned = extractSection(worldmodelContent, "Aligned Behaviors").map(
@@ -3560,8 +3963,26 @@ function isExternalScope(scope) {
   ];
   return !internalPatterns.some((p) => p.test(scope));
 }
-var MAX_INPUT_LENGTH = 1e5;
 function evaluateGuard(event, world, options = {}) {
+  const verdict = evaluateGuardCore(event, world, options);
+  return options.mode === "observe" ? toShadowVerdict(verdict) : verdict;
+}
+function toShadowVerdict(verdict) {
+  if (verdict.status === "ALLOW") return verdict;
+  return {
+    ...verdict,
+    status: "ALLOW",
+    shadowStatus: verdict.status,
+    shadowReason: verdict.reason,
+    // Preserve the original reason as shadowReason and wipe the
+    // top-level reason so callers that display `reason` for BLOCK/PAUSE
+    // don't accidentally surface an enforcement message.
+    reason: void 0,
+    warning: verdict.reason ? `Observe mode: would have ${verdict.status.toLowerCase()} \u2014 ${verdict.reason}` : `Observe mode: would have ${verdict.status.toLowerCase()}`
+  };
+}
+var MAX_INPUT_LENGTH = 1e5;
+function evaluateGuardCore(event, world, options = {}) {
   const startTime = performance.now();
   const level = options.level ?? "standard";
   const includeTrace = options.trace ?? false;
@@ -4451,6 +4872,7 @@ async function auditGovernance(events, worldPath) {
     return emptyAudit(events.length, "Could not load compiled worldmodel for governance audit.");
   }
   const verdicts = [];
+  const crossings = [];
   for (const ce of events) {
     const intent = ce.event.content?.slice(0, 500) || ce.event.kind || "activity";
     const scope = ce.event.metadata?.scope || void 0;
@@ -4461,16 +4883,32 @@ async function auditGovernance(events, worldPath) {
           scope,
           actionCategory: mapKindToCategory(ce.event.kind)
         },
-        world
+        world,
+        { mode: "observe" }
       );
+      const shadow = result.shadowStatus ?? "ALLOW";
       verdicts.push({
         eventId: ce.event.id,
         domain: ce.domain,
-        status: result.status,
-        reason: result.reason,
+        status: shadow,
+        reason: result.shadowReason,
         ruleId: result.ruleId,
         warning: result.warning
       });
+      if (shadow !== "ALLOW") {
+        crossings.push({
+          eventId: ce.event.id,
+          timestamp: ce.event.timestamp,
+          kind: ce.event.kind,
+          actorId: ce.event.actor.id,
+          shadowStatus: shadow,
+          shadowReason: result.shadowReason,
+          ruleId: result.ruleId,
+          excerpt: intent.length > 280 ? intent.slice(0, 279) + "\u2026" : intent,
+          wouldHaveBlocked: true,
+          verdict: result
+        });
+      }
     } catch {
       verdicts.push({
         eventId: ce.event.id,
@@ -4489,6 +4927,7 @@ async function auditGovernance(events, worldPath) {
     human,
     cyber,
     joint,
+    crossings,
     summary
   };
 }
@@ -4544,6 +4983,7 @@ function emptyAudit(total, reason) {
     human: { allow: 0, modify: 0, block: 0, details: [] },
     cyber: { allow: 0, modify: 0, block: 0, details: [] },
     joint: { allow: 0, modify: 0, block: 0, details: [] },
+    crossings: [],
     summary: reason
   };
 }
@@ -4926,7 +5366,8 @@ Compare stated intent against actual GitHub activity. Gaps = drift.`;
     scores,
     eventCount: events.length,
     activeAdapters,
-    worldStack
+    worldStack,
+    governance
   };
 }
 function filterEventsByUser(events, username) {
@@ -5011,16 +5452,20 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   fetchDiscordActivity,
   fetchGitHubActivity,
   fetchGitHubOrgActivity,
+  fetchGoogleWorkspaceActivity,
   fetchLinearActivity,
   fetchNotionActivity,
+  fetchSalesforceActivity,
   fetchSlackActivity,
   filterEventsByUser,
   formatActiveWorlds,
   formatDiscordSignalsForPrompt,
   formatExocortexForPrompt,
+  formatGoogleWorkspaceSignalsForPrompt,
   formatLinearSignalsForPrompt,
   formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt,
+  formatSalesforceSignalsForPrompt,
   formatScope,
   formatSlackSignalsForPrompt,
   formatTeamExocorticesForPrompt,