@sentry/junior-memory 0.179.0 → 0.181.0

package/src/tools.ts

@@ -7,6 +7,8 @@ import {
   type PluginToolOutput,
   type Source,
   type Actor,
+  type Identity,
+  type User,
   pluginToolOutputSchema,
 } from "@sentry/junior-plugin-api";
 import { z } from "zod";
@@ -43,8 +45,8 @@ const KNOWN_TOOL_INPUT_ERROR_MESSAGES = new Set([
   "Memory id is required.",
   "Memory was not found in the current context.",
   "Memory id prefix is ambiguous.",
-  "Personal memory requires actor context.",
-  "User-subject memory requires actor context.",
+  "Private memory requires a User.",
+  "User memory requires a User.",
 ]);
 
 /** Runtime-owned context used to bind memory tools to visible scopes. */
@@ -53,8 +55,12 @@ export interface MemoryToolContext {
   conversationId?: string;
   db: MemoryDb;
   embedder?: MemoryEmbeddingProvider;
+  locationId?: string;
   actor?: Actor;
   source: Source;
+  users: {
+    resolveActor(): Promise<{ identity: Identity; user?: User } | undefined>;
+  };
   userText?: string;
 }
 
@@ -79,27 +85,31 @@ function asToolInputError(error: unknown): never {
   throw error;
 }
 
-function memoryRuntimeContext(
+async function memoryRuntimeContext(
   context: MemoryToolContext,
-): MemoryRuntimeContext {
+): Promise<MemoryRuntimeContext> {
+  const actorUser = (await context.users.resolveActor())?.user;
   return memoryRuntimeContextSchema.parse({
     ...(context.conversationId
       ? { conversationId: context.conversationId }
-      : {}),
-    ...(context.actor ? { actor: context.actor } : {}),
+      : undefined),
+    ...(context.actor ? { actor: context.actor } : undefined),
+    ...(context.locationId ? { locationId: context.locationId } : undefined),
     source: context.source,
+    ...(actorUser ? { userId: actorUser.id } : undefined),
   });
 }
 
 function memoryStore(
   context: MemoryToolContext,
+  runtimeContext: MemoryRuntimeContext,
   options: { supersessionDecider?: MemorySupersessionDecider } = {},
 ) {
-  return createMemoryStore(context.db, memoryRuntimeContext(context), {
+  return createMemoryStore(context.db, runtimeContext, {
     embedder: context.embedder,
     ...(options.supersessionDecider
       ? { supersessionDecider: options.supersessionDecider }
-      : {}),
+      : undefined),
   });
 }
 
@@ -237,7 +247,7 @@ const createMemoryInputSchema = z
       .min(1)
       .max(MAX_TOOL_CONTENT_CHARS)
       .describe(
-        "Self-contained public/shareable memory candidate. Include the subject in natural language when it matters; do not rely on surrounding chat context.",
+        "Self-contained memory candidate. Include the subject in natural language when it matters; do not rely on surrounding chat context.",
       ),
     expires_at: z
       .string()
@@ -355,7 +365,7 @@ function createInput(
     kind: input.kind,
     ...(input.expiresAtMs !== undefined
       ? { expiresAtMs: input.expiresAtMs }
-      : {}),
+      : undefined),
   } satisfies CreateMemoryInput;
 }
 
@@ -375,7 +385,7 @@ function compactMemory(memory: MemoryRecord): MemoryToolProjection {
     observedAtMs: memory.observedAtMs,
     ...(memory.expiresAtMs !== undefined
       ? { expiresAtMs: memory.expiresAtMs }
-      : {}),
+      : undefined),
   });
 }
 
@@ -400,7 +410,7 @@ export function createMemoryCreateTool(context: MemoryCreateToolContext) {
       readOnlyHint: false,
     },
     description:
-      "Explicit memory-write tool. Use only when the latest user message directly asks Junior to remember, store, save, or forget-and-replace a public/shareable fact. Do not use for ordinary statements like 'I prefer X', 'I use Y', or 'X goes before Y' unless the user also asks you to remember/store/save it; passive memory learning handles those after the visible reply. Pass one self-contained natural-language candidate preserving the user's explicit memory intent. Do not ask the user to rephrase ordinary first-person facts, and do not rewrite them into display-name or third-person wording. Do not include secrets, private personal details, medical/legal/financial/sensitive facts, or another person's personal preference, opinion, habit, identity, relationship, workflow, or private life. Runtime context derives actor, scope, source, and subject ids; the memory agent decides canonical stored content and memory kind, then the plugin derives storage target from kind.",
+      "Explicit memory-write tool. Use only when the latest user message directly asks Junior to remember, store, save, or forget-and-replace a fact. Do not use for ordinary statements like 'I prefer X', 'I use Y', or 'X goes before Y' unless the user also asks you to remember/store/save it; passive memory learning handles those after the visible reply. Pass one self-contained natural-language candidate preserving the user's explicit memory intent. Do not ask the user to rephrase ordinary first-person facts, and do not rewrite them into display-name or third-person wording. Do not include secrets, private personal details, medical/legal/financial/sensitive facts, or another person's personal preference, opinion, habit, identity, relationship, workflow, or private life. Junior sets access, Location, Source, and subject. The memory agent rewrites the content and sets the memory kind.",
     executionMode: "sequential",
     inputSchema: createMemoryInputSchema,
     outputSchema: memoryCreateOutputSchema,
@@ -408,8 +418,8 @@ export function createMemoryCreateTool(context: MemoryCreateToolContext) {
       const parsedInput = parseMemoryToolInput(createMemoryInputSchema, input);
       const toolCallId = requireToolCallId(options.toolCallId);
       const requestedExpiresAtMs = parseExpiresAt(parsedInput.expires_at);
-      const runtimeContext = memoryRuntimeContext(context);
-      const store = memoryStore(context, {
+      const runtimeContext = await memoryRuntimeContext(context);
+      const store = memoryStore(context, runtimeContext, {
         supersessionDecider: context.supersessionDecider,
       });
       const review = await (async () => {
@@ -420,7 +430,7 @@ export function createMemoryCreateTool(context: MemoryCreateToolContext) {
                 content: requireMemoryContent(parsedInput.content),
                 ...(requestedExpiresAtMs !== undefined
                   ? { expiresAtMs: requestedExpiresAtMs }
-                  : {}),
+                  : undefined),
                 runtimeContext,
                 ...(context.userText?.trim()
                   ? {
@@ -428,7 +438,7 @@ export function createMemoryCreateTool(context: MemoryCreateToolContext) {
                         currentUserText: context.userText.trim(),
                       },
                     }
-                  : {}),
+                  : undefined),
               }),
             ),
           );
@@ -492,15 +502,16 @@ export function createMemoryRemoveTool(context: MemoryToolContext) {
       readOnlyHint: false,
     },
     description:
-      "Forget one memory visible in the active context. Use only ids or short id prefixes returned by listMemories or searchMemories. Never remove memories by hidden actor, Slack, scope, or subject identifiers.",
+      "Forget one private memory owned by the current User. Public memories are read-only. Use only ids or short id prefixes returned by listMemories or searchMemories. Never remove memories by hidden Actor, provider, scope, or subject ids.",
     executionMode: "sequential",
     inputSchema: removeMemoryInputSchema,
     outputSchema: memorySingleOutputSchema,
     execute: async (input) => {
       const parsedInput = parseMemoryToolInput(removeMemoryInputSchema, input);
+      const runtimeContext = await memoryRuntimeContext(context);
       const memory = await (async () => {
         try {
-          return await memoryStore(context).archiveMemory({
+          return await memoryStore(context, runtimeContext).archiveMemory({
             id: parsedInput.id,
             reason: "tool_removed",
           });
@@ -530,7 +541,8 @@ export function createMemoryListTool(context: MemoryToolContext) {
     outputSchema: memoryManyOutputSchema,
     execute: async (input) => {
       const parsedInput = parseMemoryToolInput(listMemoriesInputSchema, input);
-      const memories = await memoryStore(context).listMemories({
+      const runtimeContext = await memoryRuntimeContext(context);
+      const memories = await memoryStore(context, runtimeContext).listMemories({
         limit: boundedLimit(parsedInput.limit, DEFAULT_RESULT_LIMIT),
       });
       return memoryToolResult("listMemories", {
@@ -544,7 +556,7 @@ export function createMemoryListTool(context: MemoryToolContext) {
 export function createMemorySearchTool(context: MemoryToolContext) {
   return definePluginTool({
     description:
-      "Search active memories visible in the current context. Use when the model needs targeted memory recall. The tool searches only the current actor and active conversation scopes.",
+      "Search active memories visible in the current context. Use when the model needs targeted memory recall. Public memories are visible everywhere. Private memories belong to the current User.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -558,7 +570,11 @@ export function createMemorySearchTool(context: MemoryToolContext) {
         searchMemoriesInputSchema,
         input,
       );
-      const memories = await memoryStore(context).searchMemories({
+      const runtimeContext = await memoryRuntimeContext(context);
+      const memories = await memoryStore(
+        context,
+        runtimeContext,
+      ).searchMemories({
         query: parsedInput.query,
         limit: boundedLimit(parsedInput.limit, DEFAULT_SEARCH_LIMIT),
       });

package/src/types.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 
 export const MEMORY_KINDS = ["preference", "procedure", "knowledge"] as const;
 
-export const MEMORY_SCOPES = ["personal", "conversation"] as const;
+export const MEMORY_SCOPES = ["private", "public"] as const;
 export const MEMORY_SUBJECT_TYPES = [
   "user",
   "conversation",
@@ -22,12 +22,15 @@ export type MemoryEmbeddingMetric = (typeof MEMORY_EMBEDDING_METRICS)[number];
 
 const nonEmptyStringSchema = z.string().min(1);
 
-/** Runtime-owned memory invocation fields used for scope and source authority. */
+/** Host data used to set memory access, subject, and source. */
 export const memoryRuntimeContextSchema = z
   .object({
     conversationId: nonEmptyStringSchema.optional(),
+    locationId: nonEmptyStringSchema.optional(),
     actor: actorSchema.optional(),
     source: sourceSchema,
+    /** User linked to the active Actor. */
+    userId: nonEmptyStringSchema.optional(),
   })
   .strict();
 

package/src/user-pages.ts

@@ -1,7 +1,6 @@
-/** Project viewer-visible memories into Junior's core-rendered user page. */
+/** Render memory in Junior's User page format. */
 import type { PluginUserPageDefinition } from "@sentry/junior-plugin-api";
-import { createViewerMemories } from "./personal";
-import type { MemoryVisibility, PersonalMemoryRecord } from "./personal-store";
+import { listMemories, type MemoryVisibility, type MemoryView } from "./viewer";
 import type { MemoryDb } from "./store";
 
 function titleCase(value: string): string {
@@ -16,7 +15,7 @@ function rememberedDate(createdAtMs: number): string {
   }).format(new Date(createdAtMs));
 }
 
-function originLabel(origin: PersonalMemoryRecord["origin"]): string {
+function originLabel(origin: MemoryView["origin"]): string {
   if (origin === "automatic") return "Automatic";
   if (origin === "explicit") return "Explicit";
   return "Other";
@@ -50,17 +49,16 @@ export function createMemoryUserPage(): PluginUserPageDefinition {
     description:
       "Personal and public memories Junior can use across conversations.",
     async read(ctx, input) {
-      const memories = createViewerMemories(ctx.db as MemoryDb, ctx.viewer);
-      const page = await memories.list({
+      const page = await listMemories(ctx.db as MemoryDb, ctx.viewer.id, {
         cursor: input.cursor,
         ...pageFilter(input.filter),
         limit: input.limit,
-        ...(input.query ? { query: input.query } : {}),
+        ...(input.query ? { query: input.query } : undefined),
       });
       return {
         type: "list",
         emptyText: pageEmptyText(input),
-        ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}),
+        ...(page.nextCursor ? { nextCursor: page.nextCursor } : undefined),
         searchPlaceholder: "Search memories",
         records: page.memories.map((memory) => ({
           actions:

package/src/viewer.ts

@@ -0,0 +1,393 @@
+/**
+ * Memory access for an authenticated User.
+ *
+ * Every User can read public memory and private memory that they own.
+ */
+import {
+  and,
+  asc,
+  desc,
+  eq,
+  gt,
+  ilike,
+  isNull,
+  like,
+  lt,
+  or,
+  sql,
+} from "drizzle-orm";
+import { z } from "zod";
+import { juniorMemoryEmbeddings, juniorMemoryMemories } from "./db/schema";
+import { publicMemoryScope } from "./scope";
+import { parseMemoryRow, type MemoryDb, type MemoryRecord } from "./store";
+import { MEMORY_KINDS, type MemorySourcePlatform } from "./types";
+
+const DAY_MS = 24 * 60 * 60 * 1_000;
+const nonEmptyStringSchema = z.string().min(1);
+const memoryVisibilitySchema = z.enum(["private", "public"]);
+const cursorSchema = z
+  .object({
+    createdAtMs: z.number().finite(),
+    id: nonEmptyStringSchema,
+    kind: z.enum(MEMORY_KINDS).optional(),
+    origin: z.enum(["automatic", "explicit"]).optional(),
+    query: z.string().max(200).optional(),
+    version: z.literal(1),
+    visibility: memoryVisibilitySchema.optional(),
+  })
+  .strict();
+const pageInputSchema = z
+  .object({
+    cursor: z.string().min(1).max(1_000).optional(),
+    kind: z.enum(MEMORY_KINDS).optional(),
+    limit: z.number().int().min(1).max(50),
+    origin: z.enum(["automatic", "explicit"]).optional(),
+    query: z.string().max(200).optional(),
+    visibility: memoryVisibilitySchema.optional(),
+  })
+  .strict();
+const timelineDaysSchema = z.number().int().min(1).max(365);
+
+/** Access label returned by dashboard and REST memory views. */
+export type MemoryVisibility = z.output<typeof memoryVisibilitySchema>;
+
+/** Memory fields returned to an authenticated User. */
+export type MemoryView = MemoryRecord & {
+  origin: "automatic" | "explicit" | "other";
+  sourcePlatform: MemorySourcePlatform;
+  visibility: MemoryVisibility;
+};
+
+interface MemoryPage {
+  memories: MemoryView[];
+  nextCursor?: string;
+}
+
+type MemoryPageInput = z.output<typeof pageInputSchema>;
+
+/** Expected error for a malformed or mismatched page cursor. */
+export class InvalidMemoryCursorError extends Error {
+  constructor() {
+    super("Memory cursor is invalid.");
+    this.name = "InvalidMemoryCursorError";
+  }
+}
+
+/** Expected error when the current User cannot access a memory. */
+export class MemoryNotFoundError extends Error {
+  constructor() {
+    super("Memory was not found for this user.");
+    this.name = "MemoryNotFoundError";
+  }
+}
+
+function publicScopePredicate() {
+  return and(
+    eq(juniorMemoryMemories.scope, publicMemoryScope.scope),
+    eq(juniorMemoryMemories.scopeKey, publicMemoryScope.scopeKey),
+  );
+}
+
+function privateScopePredicate(userId: string) {
+  return and(
+    eq(juniorMemoryMemories.scope, "private"),
+    eq(juniorMemoryMemories.scopeKey, userId),
+  );
+}
+
+function visibleScopePredicate(userId: string, visibility?: MemoryVisibility) {
+  if (visibility === "public") return publicScopePredicate();
+  if (visibility === "private") return privateScopePredicate(userId);
+  return or(publicScopePredicate(), privateScopePredicate(userId));
+}
+
+function activeMemoryPredicate(
+  userId: string,
+  nowMs: number,
+  visibility?: MemoryVisibility,
+) {
+  return and(
+    visibleScopePredicate(userId, visibility),
+    isNull(juniorMemoryMemories.archivedAtMs),
+    isNull(juniorMemoryMemories.supersededAtMs),
+    isNull(juniorMemoryMemories.supersededById),
+    or(
+      isNull(juniorMemoryMemories.expiresAtMs),
+      gt(juniorMemoryMemories.expiresAtMs, nowMs),
+    ),
+  );
+}
+
+function utcDate(ms: number): string {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+function searchTerms(query: string): string[] {
+  return [
+    ...new Set(
+      query
+        .toLowerCase()
+        .split(/[^a-z0-9_'-]+/)
+        .map((term) => term.trim())
+        .filter((term) => term.length >= 2),
+    ),
+  ];
+}
+
+function memoryOrigin(idempotencyKey: string | null): MemoryView["origin"] {
+  if (idempotencyKey?.startsWith("session:")) return "automatic";
+  if (idempotencyKey?.startsWith("tool:")) return "explicit";
+  return "other";
+}
+
+function toMemoryView(
+  row: typeof juniorMemoryMemories.$inferSelect,
+): MemoryView {
+  const memory = parseMemoryRow(row);
+  return {
+    ...memory,
+    origin: memoryOrigin(row.idempotencyKey),
+    sourcePlatform: row.sourcePlatform,
+    visibility: memory.scope,
+  };
+}
+
+function cursorFilters(input: MemoryPageInput) {
+  return {
+    kind: input.kind,
+    origin: input.origin,
+    query: input.query?.trim() || undefined,
+    visibility: input.visibility,
+  };
+}
+
+function decodeCursor(
+  value: string | undefined,
+  filters: ReturnType<typeof cursorFilters>,
+) {
+  if (!value) return undefined;
+  try {
+    const parsed = cursorSchema.parse(
+      JSON.parse(Buffer.from(value, "base64url").toString("utf8")),
+    );
+    if (
+      parsed.query !== filters.query ||
+      parsed.kind !== filters.kind ||
+      parsed.origin !== filters.origin ||
+      parsed.visibility !== filters.visibility
+    ) {
+      throw new InvalidMemoryCursorError();
+    }
+    return { createdAtMs: parsed.createdAtMs, id: parsed.id };
+  } catch {
+    throw new InvalidMemoryCursorError();
+  }
+}
+
+function encodeCursor(
+  createdBefore: { createdAtMs: number; id: string },
+  filters: ReturnType<typeof cursorFilters>,
+): string {
+  return Buffer.from(
+    JSON.stringify({ ...createdBefore, ...filters, version: 1 }),
+    "utf8",
+  ).toString("base64url");
+}
+
+/** Archive one active private memory owned by the authenticated User. */
+export async function archiveMemory(db: MemoryDb, userId: string, id: string) {
+  const memoryId = nonEmptyStringSchema.parse(id);
+  const nowMs = Date.now();
+  const updated = await db
+    .update(juniorMemoryMemories)
+    .set({
+      archivedAtMs: nowMs,
+      archiveReason: "user_removed",
+    })
+    .where(
+      and(
+        activeMemoryPredicate(userId, nowMs, "private"),
+        eq(juniorMemoryMemories.id, memoryId),
+      ),
+    )
+    .returning();
+  if (!updated[0]) throw new MemoryNotFoundError();
+  await db
+    .delete(juniorMemoryEmbeddings)
+    .where(eq(juniorMemoryEmbeddings.memoryId, memoryId));
+  return parseMemoryRow(updated[0]);
+}
+
+/** Read one active memory visible to the authenticated User. */
+export async function getMemory(
+  db: MemoryDb,
+  userId: string,
+  id: string,
+): Promise<MemoryView> {
+  const memoryId = nonEmptyStringSchema.parse(id);
+  const nowMs = Date.now();
+  const rows = await db
+    .select()
+    .from(juniorMemoryMemories)
+    .where(
+      and(
+        activeMemoryPredicate(userId, nowMs),
+        eq(juniorMemoryMemories.id, memoryId),
+      ),
+    )
+    .limit(1);
+  if (!rows[0]) throw new MemoryNotFoundError();
+  return toMemoryView(rows[0]);
+}
+
+/** List one stable page of active memory visible to the authenticated User. */
+export async function listMemories(
+  db: MemoryDb,
+  userId: string,
+  input: MemoryPageInput,
+): Promise<MemoryPage> {
+  input = pageInputSchema.parse(input);
+  const filters = cursorFilters(input);
+  const cursor = decodeCursor(input.cursor, filters);
+  const active = activeMemoryPredicate(userId, Date.now(), input.visibility);
+  const createdBefore = cursor
+    ? or(
+        lt(juniorMemoryMemories.createdAtMs, cursor.createdAtMs),
+        and(
+          eq(juniorMemoryMemories.createdAtMs, cursor.createdAtMs),
+          gt(juniorMemoryMemories.id, cursor.id),
+        ),
+      )
+    : undefined;
+  const terms = input.query ? searchTerms(input.query) : [];
+  const search =
+    input.query === undefined
+      ? undefined
+      : terms.length === 0
+        ? sql`false`
+        : or(
+            ...terms.map((term) =>
+              ilike(juniorMemoryMemories.content, `%${term}%`),
+            ),
+          );
+  const kind = input.kind
+    ? eq(juniorMemoryMemories.kind, input.kind)
+    : undefined;
+  const origin =
+    input.origin === "automatic"
+      ? like(juniorMemoryMemories.idempotencyKey, "session:%")
+      : input.origin === "explicit"
+        ? like(juniorMemoryMemories.idempotencyKey, "tool:%")
+        : undefined;
+  const rows = await db
+    .select()
+    .from(juniorMemoryMemories)
+    .where(and(active, createdBefore, search, kind, origin))
+    .orderBy(
+      desc(juniorMemoryMemories.createdAtMs),
+      asc(juniorMemoryMemories.id),
+    )
+    .limit(input.limit + 1);
+  const memories = rows.slice(0, input.limit).map(toMemoryView);
+  const last = memories.at(-1);
+  if (rows.length <= input.limit || !last) return { memories };
+  const next = { createdAtMs: last.createdAtMs, id: last.id };
+  return { memories, nextCursor: encodeCursor(next, filters) };
+}
+
+/** Summarize active memory visible to the authenticated User. */
+export async function getMemoryStats(db: MemoryDb, userId: string) {
+  const nowMs = Date.now();
+  const [counts] = await db
+    .select({
+      active: sql<number>`count(*)`.mapWith(Number),
+      automatic:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'session:%')`.mapWith(
+          Number,
+        ),
+      createdThirtyDays:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${nowMs - 30 * DAY_MS})`.mapWith(
+          Number,
+        ),
+      embedded: sql<number>`count(${juniorMemoryEmbeddings.memoryId})`.mapWith(
+        Number,
+      ),
+      explicit:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'tool:%')`.mapWith(
+          Number,
+        ),
+      knowledge:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
+          Number,
+        ),
+      private:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'private')`.mapWith(
+          Number,
+        ),
+      preference:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
+          Number,
+        ),
+      procedure:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
+          Number,
+        ),
+      public:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'public')`.mapWith(
+          Number,
+        ),
+    })
+    .from(juniorMemoryMemories)
+    .leftJoin(
+      juniorMemoryEmbeddings,
+      eq(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id),
+    )
+    .where(activeMemoryPredicate(userId, nowMs));
+  if (!counts) throw new Error("Memory stats query returned no row.");
+  return counts;
+}
+
+/** Read daily memory creation totals visible to the authenticated User in UTC. */
+export async function getMemoryTimeline(
+  db: MemoryDb,
+  userId: string,
+  days: number,
+) {
+  days = timelineDaysSchema.parse(days);
+  const todayMs = Date.parse(`${utcDate(Date.now())}T00:00:00.000Z`);
+  const startMs = todayMs - (days - 1) * DAY_MS;
+  const rows = await db
+    .select({
+      date: sql<string>`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`.as(
+        "date",
+      ),
+      private:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'private')`.mapWith(
+          Number,
+        ),
+      public:
+        sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'public')`.mapWith(
+          Number,
+        ),
+    })
+    .from(juniorMemoryMemories)
+    .where(
+      and(
+        visibleScopePredicate(userId),
+        gt(juniorMemoryMemories.createdAtMs, startMs - 1),
+      ),
+    )
+    .groupBy(
+      sql`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`,
+    );
+  const byDate = new Map(rows.map((row) => [row.date, row]));
+  return Array.from({ length: days }, (_, index) => {
+    const date = utcDate(startMs + index * DAY_MS);
+    const row = byDate.get(date);
+    return {
+      date,
+      private: row?.private ?? 0,
+      public: row?.public ?? 0,
+    };
+  });
+}