@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/onboarding/schedule-checkin.ts

@@ -1,190 +0,0 @@
-/**
- * Schedules the onboarding "Day 2 Check-in" calendar event server-side.
- *
- * Flow:
- *   1. Resolve the Google OAuth connection, requiring the calendar.events scope.
- *      No connection / missing scope → a `scheduled: false` result (never an
- *      error): the web caller treats this as a best-effort skip.
- *   2. List tomorrow's timed events in the 8am–8pm window (user's timezone) to
- *      derive busy intervals. Uses events.list rather than freeBusy.query
- *      because the onboarding grant is the narrow `calendar.events` scope, which
- *      authorizes events.list/insert but not freeBusy.query.
- *   3. Choose the first open 15-minute slot (12pm–5pm, widening to 8am–8pm).
- *   4. Create the event with the locked title + HTML description, sendUpdates=all.
- *
- * Authenticates via `resolveOAuthConnection("google")` + `connection.request()`,
- * the same path the calendar watcher uses — no skill subprocess.
- */
-
-import { canonicalizeTimeZone } from "../daemon/date-context.js";
-import type { OAuthConnection } from "../oauth/connection.js";
-import { resolveOAuthConnection } from "../oauth/connection-resolver.js";
-import { getLogger } from "../util/logger.js";
-import {
-  buildCheckinDescription,
-  buildCheckinTitle,
-  checkinAvailabilityWindow,
-  type CheckinNames,
-  chooseCheckinSlot,
-  extractBusyFromEvents,
-  type GcalEvent,
-} from "./checkin-event.js";
-
-const log = getLogger("onboarding:schedule-checkin");
-
-const GOOGLE_CALENDAR_BASE_URL = "https://www.googleapis.com/calendar/v3";
-const GOOGLE_CALENDAR_EVENTS_SCOPE =
-  "https://www.googleapis.com/auth/calendar.events";
-/** Calendar shares the Google OAuth connection with Gmail. */
-const GOOGLE_PROVIDER = "google";
-const PRIMARY_CALENDAR_ID = "primary";
-
-export interface ScheduleCheckinInput extends CheckinNames {
-  /** IANA timezone reported by the client (e.g. "America/New_York"). */
-  timeZone?: string;
-  /** Override "now" for deterministic tests. Defaults to the current time. */
-  nowMs?: number;
-}
-
-export type ScheduleCheckinResult =
-  | {
-      scheduled: true;
-      eventId: string;
-      htmlLink: string | null;
-      /** Event start, ISO 8601 (UTC). */
-      start: string;
-      /** Event end, ISO 8601 (UTC). */
-      end: string;
-      timeZone: string;
-    }
-  | {
-      scheduled: false;
-      /**
-       * Why nothing was booked. `calendar_unavailable` covers both "not
-       * connected" and "calendar scope not granted" — the client surfaces a
-       * single best-effort skip either way.
-       */
-      reason: "calendar_unavailable";
-    };
-
-interface EventsListResponse {
-  items?: GcalEvent[];
-}
-
-/** Subset of the events.insert response we surface back to the caller. */
-interface CreatedEvent {
-  id?: string;
-  htmlLink?: string;
-}
-
-/**
- * Schedule the Day 2 check-in. Resolves to a `scheduled: false` result when no
- * calendar is connected; throws only on unexpected Calendar API failures (the
- * route handler maps those to a 5xx, the web caller swallows them).
- */
-export async function scheduleOnboardingCheckin(
-  input: ScheduleCheckinInput,
-): Promise<ScheduleCheckinResult> {
-  const timeZone =
-    canonicalizeTimeZone(input.timeZone) ??
-    // Fall back to the daemon host timezone when the client didn't report one.
-    Intl.DateTimeFormat().resolvedOptions().timeZone ??
-    "UTC";
-  const nowMs = input.nowMs ?? Date.now();
-
-  let connection: OAuthConnection;
-  try {
-    connection = await resolveOAuthConnection(GOOGLE_PROVIDER, {
-      requiredScopes: [GOOGLE_CALENDAR_EVENTS_SCOPE],
-    });
-  } catch (err) {
-    // No active connection or the calendar scope wasn't granted — skip quietly.
-    log.info(
-      { err: err instanceof Error ? err.message : String(err) },
-      "Check-in skipped: Google Calendar not available",
-    );
-    return { scheduled: false, reason: "calendar_unavailable" };
-  }
-
-  const { timeMinMs, timeMaxMs } = checkinAvailabilityWindow(nowMs, timeZone);
-
-  const eventsResp = await connection.request({
-    method: "GET",
-    path: `/calendars/${encodeURIComponent(PRIMARY_CALENDAR_ID)}/events`,
-    query: {
-      timeMin: new Date(timeMinMs).toISOString(),
-      timeMax: new Date(timeMaxMs).toISOString(),
-      // Expand recurring events into instances so each occurrence is a concrete
-      // busy interval in the window.
-      singleEvents: "true",
-      orderBy: "startTime",
-      maxResults: "250",
-    },
-    baseUrl: GOOGLE_CALENDAR_BASE_URL,
-    headers: { "Content-Type": "application/json" },
-  });
-  if (eventsResp.status < 200 || eventsResp.status >= 300) {
-    throw new Error(
-      `Calendar events.list ${eventsResp.status}: ${stringifyBody(eventsResp.body)}`,
-    );
-  }
-
-  const busy = extractBusyFromEvents(
-    (eventsResp.body as EventsListResponse).items ?? [],
-  );
-  const slot = chooseCheckinSlot(nowMs, timeZone, busy);
-
-  const uuid = crypto.randomUUID();
-  const eventResp = await connection.request({
-    method: "POST",
-    path: `/calendars/${encodeURIComponent(PRIMARY_CALENDAR_ID)}/events`,
-    query: { sendUpdates: "all" },
-    baseUrl: GOOGLE_CALENDAR_BASE_URL,
-    headers: { "Content-Type": "application/json" },
-    body: {
-      summary: buildCheckinTitle(input),
-      description: buildCheckinDescription(uuid),
-      start: {
-        dateTime: new Date(slot.startMs).toISOString(),
-        timeZone,
-      },
-      end: {
-        dateTime: new Date(slot.endMs).toISOString(),
-        timeZone,
-      },
-    },
-  });
-  if (eventResp.status < 200 || eventResp.status >= 300) {
-    throw new Error(
-      `Calendar event create ${eventResp.status}: ${stringifyBody(eventResp.body)}`,
-    );
-  }
-
-  const event = eventResp.body as CreatedEvent;
-  if (!event.id) {
-    throw new Error("Calendar event create returned no event id");
-  }
-
-  log.info(
-    {
-      eventId: event.id,
-      start: new Date(slot.startMs).toISOString(),
-      window: slot.window,
-      timeZone,
-    },
-    "Scheduled onboarding Day 2 check-in",
-  );
-
-  return {
-    scheduled: true,
-    eventId: event.id,
-    htmlLink: event.htmlLink ?? null,
-    start: new Date(slot.startMs).toISOString(),
-    end: new Date(slot.endMs).toISOString(),
-    timeZone,
-  };
-}
-
-function stringifyBody(body: unknown): string {
-  return typeof body === "string" ? body : JSON.stringify(body ?? "");
-}

package/src/plugins/defaults/advisor/__tests__/context-pack-gating.test.ts

@@ -1,106 +0,0 @@
-/**
- * Personal-memory gating for the advisor context pack: NOW.md and PKB must only
- * reach the advisor when the turn's trust admits personal memory (and, for
- * NOW.md, when the scratchpad-injection toggle is on) — the same policy the
- * runtime memory injectors apply. Without it, a low-risk advisor consult on a
- * remote/trusted-contact turn could forward private content the main agent
- * would never receive.
- *
- * Mocks are isolated to this file (the test runner runs each file in its own
- * process), so the broad module stubs here don't leak into other suites.
- */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-let personalAllowed = false;
-let scratchpadEnabled = true;
-let gateArg: unknown = null;
-
-mock.module("../../../../daemon/trust-context.js", () => ({
-  isPersonalMemoryAllowed: (trust: unknown) => {
-    gateArg = trust;
-    return personalAllowed;
-  },
-}));
-mock.module("../../../../daemon/now-scratchpad.js", () => ({
-  readNowScratchpad: () => "NOW-CONTENT",
-}));
-mock.module("../../../../memory/pkb/context.js", () => ({
-  readPkbContext: () => "PKB-CONTENT",
-}));
-mock.module("../../../../config/loader.js", () => ({
-  getConfig: () => ({
-    memory: {
-      retrieval: { scratchpadInjection: { enabled: scratchpadEnabled } },
-    },
-    llm: {},
-  }),
-}));
-// Keep every other section empty so the assertions isolate NOW.md / PKB.
-mock.module("../../../../daemon/conversation-workspace.js", () => ({
-  resolveWorkspaceTopLevelContext: () => null,
-}));
-mock.module("../../../../daemon/conversation-runtime-assembly.js", () => ({
-  buildActiveDocuments: () => null,
-}));
-mock.module("../../../../runtime/capabilities.js", () => ({
-  resolveCapabilities: () => ({ canAccessMemory: false }),
-}));
-mock.module("../../../../config/skills.js", () => ({
-  loadSkillCatalog: () => [],
-}));
-
-const { buildAdvisorContext } = await import("../context-pack.js");
-
-const sources = {
-  conversationId: "c1",
-  workingDir: "/tmp",
-  // A remote, non-guardian per-turn snapshot — the case the live-state read
-  // could have wrongly elevated.
-  trustClass: "unknown" as const,
-  sourceChannel: "telegram",
-  transcript: [],
-  allowedToolNames: new Set<string>(),
-};
-
-beforeEach(() => {
-  personalAllowed = false;
-  scratchpadEnabled = true;
-  gateArg = null;
-});
-
-describe("advisor context pack — personal-memory gating", () => {
-  test("withholds NOW.md and PKB when personal memory is disallowed", async () => {
-    personalAllowed = false;
-    const ctx = (await buildAdvisorContext(sources)) ?? "";
-    expect(ctx).not.toContain("NOW-CONTENT");
-    expect(ctx).not.toContain("PKB-CONTENT");
-  });
-
-  test("includes NOW.md and PKB when allowed and the scratchpad toggle is on", async () => {
-    personalAllowed = true;
-    scratchpadEnabled = true;
-    const ctx = await buildAdvisorContext(sources);
-    expect(ctx).toContain("NOW-CONTENT");
-    expect(ctx).toContain("PKB-CONTENT");
-  });
-
-  test("withholds NOW.md when the scratchpad toggle is off, PKB still allowed", async () => {
-    personalAllowed = true;
-    scratchpadEnabled = false;
-    const ctx = (await buildAdvisorContext(sources)) ?? "";
-    expect(ctx).not.toContain("NOW-CONTENT");
-    expect(ctx).toContain("PKB-CONTENT");
-  });
-
-  test("feeds the gate the per-turn trust snapshot, not live conversation state", async () => {
-    personalAllowed = true;
-    await buildAdvisorContext(sources);
-    // The gate must see exactly the snapshot threaded from ToolContext —
-    // trustClass + executionChannel — so a concurrent live-trust change can't
-    // elevate this invocation.
-    expect(gateArg).toEqual({
-      sourceChannel: "telegram",
-      trustClass: "unknown",
-    });
-  });
-});

package/src/plugins/defaults/advisor/__tests__/context-pack.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type { Message } from "../../../../providers/types.js";
-import { buildAdvisorContext, deriveRecallQuery } from "../context-pack.js";
-
-const userMsg = (t: string): Message => ({
-  role: "user",
-  content: [{ type: "text", text: t }],
-});
-
-describe("deriveRecallQuery", () => {
-  test("returns the most recent user message text", () => {
-    const query = deriveRecallQuery([
-      userMsg("the original task"),
-      { role: "assistant", content: [{ type: "text", text: "ok" }] },
-      userMsg("the latest question"),
-    ]);
-    expect(query).toBe("the latest question");
-  });
-
-  test("returns null when there is no user text", () => {
-    expect(
-      deriveRecallQuery([
-        { role: "assistant", content: [{ type: "text", text: "hi" }] },
-      ]),
-    ).toBeNull();
-    expect(deriveRecallQuery([])).toBeNull();
-  });
-});
-
-describe("buildAdvisorContext", () => {
-  test("lists the agent's available tools, skipping the advisor itself", async () => {
-    const context = await buildAdvisorContext({
-      conversationId: "ctx-1",
-      workingDir: "/tmp/does-not-exist",
-      allowedToolNames: new Set(["bash", "advisor", "read_file"]),
-      trustClass: "unknown",
-      transcript: [userMsg("hi")],
-    });
-
-    expect(context).toContain("## Available tools");
-    expect(context).toContain("- bash");
-    expect(context).toContain("- read_file");
-    // The advisor advises; it never tells the agent to consult itself.
-    expect(context).not.toContain("- advisor");
-  });
-
-  test("omits the tools section when no tools are available", async () => {
-    const context = await buildAdvisorContext({
-      conversationId: "ctx-2",
-      workingDir: "/tmp/does-not-exist",
-      allowedToolNames: new Set(),
-      trustClass: "unknown",
-      transcript: [],
-    });
-    // Other sources (e.g. the skills catalog) may still contribute, but with no
-    // allowed tools the tools section must not appear.
-    if (context !== null) expect(context).not.toContain("## Available tools");
-  });
-});

package/src/plugins/defaults/advisor/context-pack.ts

@@ -1,288 +0,0 @@
-/**
- * Assemble the runtime context the advisor needs to make grounded
- * recommendations — the same situational awareness the executing agent has:
- *  - the tools available to it this turn,
- *  - the skills it can load,
- *  - the loaded workspace / project context, NOW.md, PKB, and open documents,
- *  - and relevant memory pulled through the recall search.
- *
- * The advisor already receives the agent's transcript and system prompt; this
- * adds the situational context that lives *outside* the prompt (tools and
- * skills are passed to the model as a separate catalog, not inlined) plus a
- * fresh, task-focused memory recall.
- *
- * Personal-memory surfaces are gated to the same policy the main agent's
- * memory injectors apply: the recall search honors `canAccessMemory` (like the
- * `recall` tool), and NOW.md / PKB honor `isPersonalMemoryAllowed` (plus the
- * scratchpad-injection toggle for NOW.md). The advisor tool is low-risk and can
- * run on remote/trusted-contact turns, so without these gates it could forward
- * private content the main agent itself would not receive.
- *
- * Every section is best-effort: each source is wrapped so a failure or empty
- * result drops just that section, never the consult. Daemon- and memory-side
- * modules are pulled in via dynamic `import()` so this plugin module — loaded
- * at bootstrap through `defaults/index.ts` — never forms a static import cycle
- * with them. The result is a single string injected into the advisor's system
- * prompt (see `buildAdvisorSystem`), or `null` when nothing could be gathered.
- */
-
-import type { ChannelId } from "../../../channels/types.js";
-import type { TrustContext } from "../../../daemon/trust-context.js";
-import type { Message } from "../../../providers/types.js";
-import type { TrustClass } from "../../../runtime/actor-trust-resolver.js";
-
-export interface AdvisorContextSources {
-  conversationId: string;
-  workingDir: string;
-  /** The live tool set the executor sees this turn (`ToolContext.allowedToolNames`). */
-  allowedToolNames?: ReadonlySet<string>;
-  /**
-   * Trust class of the turn's actor, from the per-turn `ToolContext.trustClass`
-   * snapshot. Gates the memory recall and (with {@link sourceChannel}) the
-   * personal-memory surfaces.
-   */
-  trustClass: TrustClass;
-  /**
-   * Channel the turn originates on, from the per-turn `ToolContext.executionChannel`
-   * snapshot. Combined with {@link trustClass} to evaluate personal-memory
-   * access exactly as the injectors do, off the same per-turn snapshot rather
-   * than the mutable live conversation trust.
-   */
-  sourceChannel?: string;
-  /** The captured transcript, used to derive the recall query. */
-  transcript: ReadonlyArray<Message>;
-  signal?: AbortSignal;
-}
-
-/** Cap a block so the assembled context never balloons the consult prompt. */
-function truncate(text: string, max: number): string {
-  const trimmed = text.trim();
-  return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max)}…`;
-}
-
-/** First sentence (or a capped prefix) of a tool/skill description. */
-function summarize(description: string | undefined, max = 160): string {
-  if (!description) return "";
-  const firstSentence = description.split(/(?<=[.!?])\s/)[0] ?? description;
-  return truncate(firstSentence, max);
-}
-
-/** Pull the most recent user-authored text to seed the memory recall query. */
-export function deriveRecallQuery(
-  transcript: ReadonlyArray<Message>,
-): string | null {
-  for (let i = transcript.length - 1; i >= 0; i--) {
-    const message = transcript[i];
-    if (message.role !== "user") continue;
-    const text = message.content
-      .map((block) => (block.type === "text" ? block.text : ""))
-      .join(" ")
-      .trim();
-    if (text.length > 0) return truncate(text, 500);
-  }
-  return null;
-}
-
-/** `## Available tools` — the live tool set the agent can act with this turn. */
-async function buildToolsSection(
-  allowedToolNames: ReadonlySet<string> | undefined,
-): Promise<string | null> {
-  if (!allowedToolNames || allowedToolNames.size === 0) return null;
-  try {
-    const { getTool } = await import("../../../tools/registry.js");
-    const lines: string[] = [];
-    for (const name of [...allowedToolNames].sort()) {
-      // The advisor advises; it never recommends consulting itself.
-      if (name === "advisor") continue;
-      const summary = summarize(getTool(name)?.description);
-      lines.push(summary ? `- ${name} — ${summary}` : `- ${name}`);
-    }
-    if (lines.length === 0) return null;
-    return `## Available tools (what the agent can do)\n${lines.join("\n")}`;
-  } catch {
-    return null;
-  }
-}
-
-/** `## Available skills` — the skills the agent can load via `skill_load`. */
-async function buildSkillsSection(): Promise<string | null> {
-  try {
-    const { loadSkillCatalog } = await import("../../../config/skills.js");
-    const catalog = loadSkillCatalog();
-    if (catalog.length === 0) return null;
-    const lines = catalog.slice(0, 60).map((skill) => {
-      const summary = summarize(skill.description);
-      const when = skill.activationHints?.length
-        ? ` (use when: ${truncate(skill.activationHints.join("; "), 120)})`
-        : "";
-      const label = skill.displayName || skill.name || skill.id;
-      return `- ${label} (${skill.id})${summary ? ` — ${summary}` : ""}${when}`;
-    });
-    const more =
-      catalog.length > 60 ? `\n- …and ${catalog.length - 60} more` : "";
-    return `## Available skills (load with skill_load)\n${lines.join("\n")}${more}`;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Whether personal-memory surfaces (NOW.md, PKB) may be exposed to the advisor
- * — the same `isPersonalMemoryAllowed` gate the runtime memory injectors apply.
- *
- * Derived from the per-turn trust snapshot (`ToolContext.trustClass` /
- * `executionChannel`, threaded in via {@link AdvisorContextSources}), NOT the
- * live `findConversation().trustContext`: that conversation state is mutable
- * and a concurrent guardian/meta command could flip it to guardian mid-flight,
- * granting a remote/non-guardian turn access its own snapshot was never given.
- * Fail-closed: if the gate can't be resolved, returns false.
- */
-async function personalMemoryAllowedForAdvisor(
-  trustClass: TrustClass,
-  sourceChannel: string | undefined,
-): Promise<boolean> {
-  try {
-    const { isPersonalMemoryAllowed } =
-      await import("../../../daemon/trust-context.js");
-    // `isPersonalMemoryAllowed` reads only `sourceChannel` + `trustClass`; build
-    // a minimal trust context from the per-turn snapshot. The channel may be
-    // absent (local/internal turns), which the gate treats as non-remote.
-    const snapshot = {
-      sourceChannel: sourceChannel as ChannelId | undefined,
-      trustClass,
-    } as TrustContext;
-    return isPersonalMemoryAllowed(snapshot);
-  } catch {
-    return false;
-  }
-}
-
-/** `## Workspace & project context` — the loaded environment around the agent. */
-async function buildWorkspaceSection(
-  sources: AdvisorContextSources,
-): Promise<string | null> {
-  const { conversationId } = sources;
-  const parts: string[] = [];
-
-  // The `<workspace>` directory listing is not personal memory — the agent's
-  // own file tools already operate in this cwd — so it is surfaced ungated, the
-  // same way the workspace-context injector does.
-  try {
-    const { resolveWorkspaceTopLevelContext } =
-      await import("../../../daemon/conversation-workspace.js");
-    const workspace = resolveWorkspaceTopLevelContext(conversationId);
-    if (workspace) parts.push(truncate(workspace, 2500));
-  } catch {
-    /* best-effort */
-  }
-
-  // NOW.md and PKB are personal-memory surfaces. Gate them behind the same
-  // `isPersonalMemoryAllowed` policy (and, for NOW.md, the scratchpad-injection
-  // toggle) the runtime injectors use, evaluated off the per-turn trust
-  // snapshot, so a low-risk advisor consult cannot forward private content the
-  // main agent would never receive.
-  if (
-    await personalMemoryAllowedForAdvisor(
-      sources.trustClass,
-      sources.sourceChannel,
-    )
-  ) {
-    try {
-      const [{ readNowScratchpad }, { getConfig }] = await Promise.all([
-        import("../../../daemon/now-scratchpad.js"),
-        import("../../../config/loader.js"),
-      ]);
-      if (getConfig().memory.retrieval.scratchpadInjection.enabled) {
-        const now = readNowScratchpad();
-        if (now) parts.push(`NOW.md scratchpad:\n${truncate(now, 1500)}`);
-      }
-    } catch {
-      /* best-effort */
-    }
-
-    try {
-      const { readPkbContext } = await import("../../../memory/pkb/context.js");
-      const pkb = readPkbContext();
-      if (pkb) parts.push(truncate(pkb, 1500));
-    } catch {
-      /* best-effort */
-    }
-  }
-
-  try {
-    const { buildActiveDocuments } =
-      await import("../../../daemon/conversation-runtime-assembly.js");
-    const docs = buildActiveDocuments(conversationId);
-    if (docs && docs.length > 0) {
-      const titles = docs
-        .slice(0, 20)
-        .map((doc) => `- ${doc.title} (${doc.wordCount} words)`)
-        .join("\n");
-      parts.push(`Open documents:\n${titles}`);
-    }
-  } catch {
-    /* best-effort */
-  }
-
-  if (parts.length === 0) return null;
-  return `## Workspace & project context\n${parts.join("\n\n")}`;
-}
-
-/** `## Relevant memory (recall)` — a fresh, task-focused recall search. */
-async function buildMemorySection(
-  sources: AdvisorContextSources,
-): Promise<string | null> {
-  try {
-    const { resolveCapabilities } =
-      await import("../../../runtime/capabilities.js");
-    // Recall reads sensitive local context; honor the same trust gate the
-    // `recall` tool applies. Non-guardian turns get no fresh recall here.
-    if (!resolveCapabilities(sources.trustClass).canAccessMemory) return null;
-
-    const query = deriveRecallQuery(sources.transcript);
-    if (!query) return null;
-
-    const [{ runDeterministicRecallSearch }, { getConfig }] = await Promise.all(
-      [
-        import("../../../memory/context-search/search.js"),
-        import("../../../config/loader.js"),
-      ],
-    );
-
-    const { evidence } = await runDeterministicRecallSearch(
-      { query, max_results: 8 },
-      {
-        workingDir: sources.workingDir,
-        conversationId: sources.conversationId,
-        config: getConfig(),
-        signal: sources.signal,
-      },
-    );
-    if (evidence.length === 0) return null;
-
-    const lines = evidence.slice(0, 8).map((item) => {
-      const excerpt = truncate(item.excerpt, 220);
-      return `- [${item.source}] ${item.title} (${item.locator}): ${excerpt}`;
-    });
-    return `## Relevant memory (recall: "${truncate(query, 120)}")\n${lines.join("\n")}`;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Gather the advisor's runtime context block, or `null` if nothing is
- * available. Sections run concurrently; each is independently best-effort.
- */
-export async function buildAdvisorContext(
-  sources: AdvisorContextSources,
-): Promise<string | null> {
-  const sections = await Promise.all([
-    buildToolsSection(sources.allowedToolNames),
-    buildSkillsSection(),
-    buildWorkspaceSection(sources),
-    buildMemorySection(sources),
-  ]);
-  const present = sections.filter((s): s is string => s !== null);
-  return present.length > 0 ? present.join("\n\n") : null;
-}