@sentry/junior-memory 0.76.0

package/src/agent.ts

@@ -0,0 +1,437 @@
+import type { PluginModel } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+import { memoryRuntimeContextSchema } from "./types";
+
+const memoryTargetSchema = z.enum(["requester", "conversation"]);
+const memoryKindSchema = z.enum(["preference", "procedure", "fact"]);
+const memoryRejectReasonSchema = z.enum([
+  "not_public_shareable",
+  "secret_or_credential",
+  "sensitive_personal",
+  "third_party_personal",
+  "vague_or_not_self_contained",
+  "not_durable",
+  "assistant_or_system_detail",
+  "unsupported_scope",
+]);
+const createMemoryRequestSchema = z
+  .object({
+    content: z.string().min(1),
+    expiresAtMs: z.number().finite().optional(),
+    runtimeContext: memoryRuntimeContextSchema,
+    sourceContext: z
+      .object({
+        currentUserText: z.string().min(1).optional(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict();
+const extractSessionRequestSchema = z
+  .object({
+    existingMemories: z
+      .array(
+        z
+          .object({
+            content: z.string().min(1),
+          })
+          .strict(),
+      )
+      .max(10)
+      .default([]),
+    runtimeContext: memoryRuntimeContextSchema,
+    transcript: z
+      .array(
+        z.discriminatedUnion("type", [
+          z
+            .object({
+              type: z.literal("message"),
+              role: z.enum(["user", "assistant"]),
+              text: z.string().min(1),
+            })
+            .strict(),
+          z
+            .object({
+              type: z.literal("toolResult"),
+              toolName: z.string().min(1),
+              isError: z.boolean(),
+              text: z.string().min(1),
+            })
+            .strict(),
+        ]),
+      )
+      .min(1),
+  })
+  .strict();
+
+const expiresAtMsSchema = z
+  .number()
+  .finite()
+  .nullable()
+  .describe(
+    "Expiration timestamp when the fact should expire, otherwise null.",
+  );
+const memoryReviewDecisionSchema = z.discriminatedUnion("decision", [
+  z
+    .object({
+      decision: z.literal("store"),
+      target: memoryTargetSchema,
+      content: z.string().min(1),
+      expiresAtMs: z.number().finite().optional(),
+    })
+    .strict(),
+  z
+    .object({
+      decision: z.literal("reject"),
+      reason: memoryRejectReasonSchema,
+    })
+    .strict(),
+]);
+const memoryReviewResponseSchema = z.discriminatedUnion("decision", [
+  z
+    .object({
+      decision: z.literal("store"),
+      kind: memoryKindSchema.describe(
+        "Use preference only for requester-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use fact for shared project, channel, operational, or runbook knowledge.",
+      ),
+      canonicalFact: z
+        .string()
+        .min(1)
+        .describe(
+          "Stored memory text. It must be self-contained and must not include requester names, requester/user labels, source labels, or first- or second-person wording.",
+        ),
+      expiresAtMs: expiresAtMsSchema,
+    })
+    .strict(),
+  z
+    .object({
+      decision: z.literal("reject"),
+      reason: memoryRejectReasonSchema,
+    })
+    .strict(),
+]);
+const extractedMemorySchema = z
+  .object({
+    kind: memoryKindSchema.describe(
+      "Use preference only for requester-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use fact for shared project, channel, operational, or runbook knowledge.",
+    ),
+    canonicalFact: z
+      .string()
+      .min(1)
+      .describe(
+        "Stored memory text as one self-contained fact. It must not include requester names, requester/user labels, source labels, or first- or second-person wording.",
+      ),
+    expiresAtMs: expiresAtMsSchema,
+  })
+  .strict();
+const extractMemoriesResponseSchema = z
+  .object({
+    memories: z
+      .array(extractedMemorySchema)
+      .max(5)
+      .describe(
+        "Accepted public/shareable durable memories from the completed run. Return one object per distinct source assertion and classify it with kind.",
+      ),
+  })
+  .strict();
+
+type MemoryReviewResponse = z.output<typeof memoryReviewResponseSchema>;
+type ExtractMemoriesResponse = z.output<typeof extractMemoriesResponseSchema>;
+
+export type MemoryTarget = z.output<typeof memoryTargetSchema>;
+type MemoryKind = z.output<typeof memoryKindSchema>;
+
+export type MemoryReview = z.output<typeof memoryReviewDecisionSchema>;
+
+export type CreateMemoryRequest = z.output<typeof createMemoryRequestSchema>;
+export type ExtractSessionRequest = z.output<
+  typeof extractSessionRequestSchema
+>;
+export interface ExtractedMemory {
+  content: string;
+  expiresAtMs: number | null;
+  target: MemoryTarget;
+}
+
+export interface MemoryAgent {
+  extractSessionMemories(
+    request: ExtractSessionRequest,
+  ): Promise<ExtractedMemory[]> | ExtractedMemory[];
+  reviewCreateRequest(
+    request: CreateMemoryRequest,
+  ): Promise<MemoryReview> | MemoryReview;
+}
+
+const MEMORY_REVIEW_SYSTEM = [
+  "You are Junior's memory review agent.",
+  "Review one memory candidate and return one structured review decision.",
+  "Store only public/shareable, self-contained facts that are useful beyond this turn.",
+  "Reject secrets, credentials, private or sensitive personal details, gossip, speculative claims about other people, assistant/system implementation details, vague references, and low-durability chatter.",
+  "Use the runtime context only for authority and scope; do not accept model-provided actor ids, scope ids, aliases, or arbitrary subjects.",
+].join("\n");
+const MEMORY_EXTRACTION_SYSTEM = [
+  "You are Junior's passive memory extraction agent. Return only structured memories worth storing.",
+  "Use the completed run transcript as source evidence, including user-authored messages and tool results.",
+  "Assistant text is context for interpreting the run, not independent evidence for new facts.",
+  "Reject secrets, credentials, private or sensitive personal details, gossip, speculative claims about other people, assistant/system implementation details, vague references, and low-durability chatter.",
+  "If no public, durable, self-contained memory remains after rewriting, return an empty memories array.",
+].join("\n");
+const CANONICAL_CONTENT_RULES = [
+  "- Stored memory text must be a rewritten fact, not copied user wording or a sentence about who said it.",
+  "- Store the minimum useful assertion supported by source evidence; do not add adjacent steps, caveats, or generalized advice.",
+  "- Do not return both concise and expanded variants of the same source assertion; keep the shortest self-contained canonical memory.",
+  "- Put ownership in structured fields, not prose.",
+  "- For requester memories, omit the subject and write a stable fact such as 'Prefers X', 'Uses Y', or 'Thinks Z'.",
+  "- Drop perspective/provenance markers while preserving useful context.",
+  "- Remove requester names, display names, requester/user labels, first- or second-person wording, thread labels, channel labels, and source labels.",
+];
+
+function targetForKind(kind: MemoryKind): MemoryTarget {
+  if (kind === "preference") {
+    return "requester";
+  }
+  return "conversation";
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}
+
+function runtimeDescription(
+  request: Pick<CreateMemoryRequest, "expiresAtMs" | "runtimeContext">,
+): string {
+  const runtime = request.runtimeContext;
+  const requester =
+    runtime.requester?.platform === "slack"
+      ? `slack:${runtime.requester.teamId}:${runtime.requester.userId}`
+      : runtime.requester?.platform === "local"
+        ? `local:${runtime.requester.userId}`
+        : "none";
+  const source =
+    runtime.source.platform === "slack"
+      ? `slack:${runtime.source.teamId}:${runtime.source.channelId}`
+      : `local:${runtime.source.conversationId}`;
+  const lines = [
+    `- requester: ${escapeXml(requester)}`,
+    `- source: ${escapeXml(source)}`,
+    `- has_conversation: ${runtime.conversationId ? "true" : "false"}`,
+    `- expires_at: ${
+      request.expiresAtMs === undefined
+        ? "never"
+        : escapeXml(new Date(request.expiresAtMs).toISOString())
+    }`,
+  ];
+  return ["<runtime>", ...lines, "</runtime>"].join("\n");
+}
+
+function sourceContext(request: CreateMemoryRequest): string | undefined {
+  const currentUserText = request.sourceContext?.currentUserText?.trim();
+  if (!currentUserText) {
+    return undefined;
+  }
+  return [
+    "<source-context>",
+    "The current user-authored text is source evidence for explicit memory requests. Use it to recover the concrete fact when the candidate is incomplete, vague, or over-personalized. Store only rewritten, self-contained memory content.",
+    "<current-user-message>",
+    escapeXml(currentUserText),
+    "</current-user-message>",
+    "</source-context>",
+  ].join("\n");
+}
+
+function existingMemoriesContext(request: ExtractSessionRequest): string {
+  if (request.existingMemories.length === 0) {
+    return "<existing-memories>[]</existing-memories>";
+  }
+  return [
+    "<existing-memories>",
+    "Use these only to skip memories that are already covered or semantically redundant. They are not source evidence for new memories.",
+    escapeXml(JSON.stringify(request.existingMemories)),
+    "</existing-memories>",
+  ].join("\n");
+}
+
+function memoryKindsContext(): string {
+  return [
+    "<memory-kinds>",
+    "- preference: a durable first-person personal preference, opinion, habit, or workflow owned by the current requester. Stored as requester memory.",
+    "- procedure: reusable instructions for how a task, lookup, investigation, process, triage flow, or runbook should be done. Store the method, source-of-truth, prerequisite, or decision path when it took effort to discover. Stored as conversation memory.",
+    "- fact: stable shared project, channel, operational, or runbook knowledge that is not a personal requester preference. Direct answers to user inquiries qualify only when they are durable beyond this run. Stored as conversation memory.",
+    "</memory-kinds>",
+  ].join("\n");
+}
+
+function reviewPrompt(request: CreateMemoryRequest): string {
+  const sections = [
+    "<memory-review-input>",
+    "Review the candidate memory using the runtime-owned context below.",
+    "",
+    runtimeDescription(request),
+    "",
+    sourceContext(request),
+    "",
+    "<candidate>",
+    escapeXml(request.content),
+    "</candidate>",
+    "",
+    "<rules>",
+    "- Return store only when the candidate is public/shareable, durable, and self-contained.",
+    "- First classify the memory kind: preference, procedure, or fact.",
+    "- Use kind=preference only for first-person facts authored by the current requester about their own preference, opinion, habit, identity, or workflow.",
+    "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current requester.",
+    "- Use kind=procedure for reusable task/process/runbook instructions.",
+    "- Use kind=fact for shared project, channel, operational, or runbook knowledge.",
+    "- When current-user-message contains an explicit memory request with a concrete fact or procedure, extract from current-user-message even if the candidate is vague, incomplete, or phrased as an instruction.",
+    "- A candidate may be badly phrased by an outer assistant or extraction pass. When current-user-message contains the requester's own first-person memory fact, treat that as requester-authored source evidence and canonicalize the fact instead of rejecting for third-person wording.",
+    "- When candidate wording personalizes a shared task, process, runbook, project, channel, or operational fact, use current-user-message to recover the shared fact and classify it as procedure or fact.",
+    "- Explicit procedure requests are valid when the source text contains both task context and action. Canonicalize them as shared procedure facts instead of rejecting them as vague.",
+    "- Store content as person-less, source-less canonical knowledge. Ownership and source live in structured metadata, not prose.",
+    "- For requester memories, omit the subject and write the content as a stable fact such as 'Prefers X', 'Uses Y', or 'Thinks Z'.",
+    "- Remove requester names, display names, requester/user labels, first- or second-person wording, thread labels, channel labels, and source labels from stored content.",
+    "- Reject third-party personal profile facts, even if they mention a name.",
+    "- Reject vague content such as 'remember this' unless the candidate or current-user-message contains the concrete fact.",
+    "- Preserve the requested expiration when one exists; otherwise set expiresAtMs to null.",
+    "- If unsure, reject.",
+    "</rules>",
+    "</memory-review-input>",
+  ].filter((section): section is string => section !== undefined);
+  return sections.join("\n");
+}
+
+function runTranscriptContext(request: ExtractSessionRequest): string {
+  return [
+    "<run-transcript>",
+    ...request.transcript.map((entry, index) => {
+      if (entry.type === "toolResult") {
+        return [
+          `<tool-result index="${index}" tool="${escapeXml(entry.toolName)}" is_error="${entry.isError ? "true" : "false"}">`,
+          escapeXml(entry.text),
+          "</tool-result>",
+        ].join("\n");
+      }
+      return [
+        `<message index="${index}" role="${entry.role}">`,
+        escapeXml(entry.text),
+        "</message>",
+      ].join("\n");
+    }),
+    "</run-transcript>",
+  ].join("\n");
+}
+
+function sessionExtractionPrompt(request: ExtractSessionRequest): string {
+  return [
+    "<memory-extraction-input>",
+    "Extract durable memories from this completed agent run using the runtime-owned context below.",
+    "",
+    runtimeDescription({
+      runtimeContext: request.runtimeContext,
+    }),
+    "",
+    existingMemoriesContext(request),
+    "",
+    memoryKindsContext(),
+    "",
+    runTranscriptContext(request),
+    "",
+    "<rules>",
+    "- Return at most five memories.",
+    "- Use user messages and successful tool results as source evidence for storable facts.",
+    "- Use failed tool results only when the failure reveals durable process knowledge, not transient errors.",
+    "- Use assistant messages only as context; do not store the assistant's claims unless supported by user messages or tool results.",
+    "- Return one memory per distinct fact.",
+    "- Prefer storing how to achieve a result: stable source-of-truth, query location, workflow, prerequisite, caveat, or reusable decision path that took effort to discover.",
+    "- Store direct answers to user inquiries only when they are stable operational/project knowledge, not values that naturally change over time.",
+    "- Do not store point-in-time analytics, search, issue, metric, incident, availability, or status answers just because a tool produced them.",
+    "- Do not store the fact that the user asked for advice, search, recall, planning, listing, inspection, or removal. Store only stable knowledge discovered in response, such as a reusable method or source-of-truth.",
+    "- A user question asking how, what, where, or whether to do something is not source evidence for the answer. Store the answer only when supported by a user-authored factual statement or a tool result.",
+    "- Set kind=procedure for reusable task/process/runbook instructions.",
+    "- Set kind=fact for shared team, project, channel, runbook, or operational knowledge.",
+    "- Set kind=preference only for clear durable first-person facts authored by the current requester about their own preference, opinion, habit, identity, or workflow.",
+    "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current requester.",
+    "- User-authored task instructions are procedures, not preferences, unless they explicitly describe the requester's personal preference or habit.",
+    "- Procedural statements such as 'for X, do Y', 'when X, do Y', and 'to accomplish X, do Y' belong in procedures.",
+    ...CANONICAL_CONTENT_RULES,
+    "- Skip a candidate when existing-memories already cover the same durable fact.",
+    "- Reject third-party personal profile facts, even if they mention a name.",
+    "- If unsure, return no memory for that candidate.",
+    "</rules>",
+    "</memory-extraction-input>",
+  ].join("\n");
+}
+
+/** Create the memory-owned agent that reviews and extracts memory candidates. */
+export function createMemoryAgent(model: PluginModel): MemoryAgent {
+  return {
+    async extractSessionMemories(rawRequest) {
+      const request = extractSessionRequestSchema.parse(rawRequest);
+      const result = await model.completeObject({
+        schema: extractMemoriesResponseSchema,
+        system: MEMORY_EXTRACTION_SYSTEM,
+        prompt: sessionExtractionPrompt(request),
+        maxTokens: 1_000,
+      });
+      return extractedMemoriesFromResponse(
+        extractMemoriesResponseSchema.parse(result.object),
+      );
+    },
+    async reviewCreateRequest(rawRequest) {
+      const request = parseCreateMemoryRequest(rawRequest);
+      const result = await model.completeObject({
+        schema: memoryReviewResponseSchema,
+        system: MEMORY_REVIEW_SYSTEM,
+        prompt: reviewPrompt(request),
+        maxTokens: 700,
+      });
+      const response = memoryReviewResponseSchema.parse(result.object);
+      return memoryReviewFromResponse(response);
+    },
+  };
+}
+
+function memoryReviewFromResponse(
+  response: MemoryReviewResponse,
+): MemoryReview {
+  if (response.decision === "store") {
+    return parseMemoryReview({
+      decision: "store",
+      target: targetForKind(response.kind),
+      content: response.canonicalFact,
+      ...(response.expiresAtMs !== null
+        ? { expiresAtMs: response.expiresAtMs }
+        : {}),
+    });
+  }
+  return parseMemoryReview({
+    decision: "reject",
+    reason: response.reason,
+  });
+}
+
+function extractedMemoriesFromResponse(
+  response: ExtractMemoriesResponse,
+): ExtractedMemory[] {
+  const toMemory = (
+    memory: z.output<typeof extractedMemorySchema>,
+  ): ExtractedMemory => ({
+    content: memory.canonicalFact,
+    expiresAtMs: memory.expiresAtMs,
+    target: targetForKind(memory.kind),
+  });
+  return response.memories.map(toMemory);
+}
+
+/** Parse the structured decision returned by the memory agent. */
+export function parseMemoryReview(result: unknown): MemoryReview {
+  return memoryReviewDecisionSchema.parse(result);
+}
+
+/** Parse the structured input sent to the memory agent. */
+export function parseCreateMemoryRequest(
+  request: unknown,
+): CreateMemoryRequest {
+  return createMemoryRequestSchema.parse(request);
+}

package/src/cli/format.ts

@@ -0,0 +1,30 @@
+import type { juniorMemoryMemories } from "../db/schema";
+
+function formatDate(ms: number | null): string {
+  return ms === null ? "-" : new Date(ms).toISOString();
+}
+
+/** Format a memory row as an operator-safe CLI projection. */
+export function formatMemory(
+  row: typeof juniorMemoryMemories.$inferSelect,
+  args: {
+    showContent: boolean;
+  },
+): string {
+  const lines = [
+    `id=${row.id}`,
+    `scope=${row.scope}`,
+    `scope_key=${row.scopeKey}`,
+    `subject_type=${row.subjectType}`,
+    ...(row.subjectKey ? [`subject_key=${row.subjectKey}`] : []),
+    `type=${row.type}`,
+    `created_at=${formatDate(row.createdAtMs)}`,
+    `observed_at=${formatDate(row.observedAtMs)}`,
+    `expires_at=${formatDate(row.expiresAtMs)}`,
+    `archived_at=${formatDate(row.archivedAtMs)}`,
+  ];
+  if (args.showContent) {
+    lines.push(`content=${row.content}`);
+  }
+  return lines.join("\n");
+}

package/src/cli/index.ts

@@ -0,0 +1,15 @@
+import type { PluginCliCommandDefinition } from "@sentry/junior-plugin-api";
+import { configureMemorySearchCommand } from "./search";
+import { configureMemoryShowCommand } from "./show";
+
+/** Create the plugin-owned memory admin CLI command. */
+export function createMemoryCliCommand(): PluginCliCommandDefinition {
+  return {
+    name: "memory",
+    summary: "Inspect Junior memory state",
+    configure(command, junior) {
+      configureMemorySearchCommand(command, junior);
+      configureMemoryShowCommand(command, junior);
+    },
+  };
+}

package/src/cli/search.ts

@@ -0,0 +1,119 @@
+import { InvalidArgumentError, Option, type Command } from "commander";
+import { and, desc, eq, gt, ilike, isNull, or, type SQL } from "drizzle-orm";
+import type {
+  PluginCliActionContext,
+  PluginCliHost,
+} from "@sentry/junior-plugin-api";
+import { juniorMemoryMemories } from "../db/schema";
+import type { MemoryDb } from "../store";
+import { MEMORY_SCOPES, type MemoryScope } from "../types";
+import { formatMemory } from "./format";
+
+interface SearchOptions {
+  limit: number;
+  scope: MemoryScope;
+  scopeKey: string;
+  showContent?: boolean;
+}
+
+function parseLimit(value: string): number {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new InvalidArgumentError("--limit must be a number");
+  }
+  return Math.min(100, Math.max(1, Math.floor(parsed)));
+}
+
+async function runSearch(
+  ctx: PluginCliActionContext,
+  queryParts: string[] | undefined,
+  options: SearchOptions,
+): Promise<number> {
+  const query = (queryParts ?? []).join(" ").trim();
+  const nowMs = Date.now();
+  const terms = [
+    ...new Set(
+      query
+        .toLowerCase()
+        .split(/[^a-z0-9_'-]+/)
+        .map((term) => term.trim())
+        .filter((term) => term.length >= 2),
+    ),
+  ];
+
+  const db = ctx.db as MemoryDb;
+  const activeExpirationPredicate = or(
+    isNull(juniorMemoryMemories.expiresAtMs),
+    gt(juniorMemoryMemories.expiresAtMs, nowMs),
+  );
+  const predicates: SQL[] = [
+    eq(juniorMemoryMemories.scope, options.scope),
+    eq(juniorMemoryMemories.scopeKey, options.scopeKey),
+    isNull(juniorMemoryMemories.archivedAtMs),
+    isNull(juniorMemoryMemories.supersededAtMs),
+    isNull(juniorMemoryMemories.supersededById),
+  ];
+  if (activeExpirationPredicate) {
+    predicates.push(activeExpirationPredicate);
+  }
+  if (terms.length > 0) {
+    const termPredicate = or(
+      ...terms.map((term) => ilike(juniorMemoryMemories.content, `%${term}%`)),
+    );
+    if (termPredicate) {
+      predicates.push(termPredicate);
+    }
+  }
+  const rows = await db
+    .select()
+    .from(juniorMemoryMemories)
+    .where(and(...predicates))
+    .orderBy(desc(juniorMemoryMemories.createdAtMs))
+    .limit(options.limit);
+
+  if (rows.length === 0) {
+    await ctx.io.writeOutput("No memories matched.\n");
+    return 0;
+  }
+
+  await ctx.io.writeOutput(
+    `${rows
+      .map((row) =>
+        formatMemory(row, { showContent: Boolean(options.showContent) }),
+      )
+      .join("\n\n")}\n`,
+  );
+  return 0;
+}
+
+/** Wire the memory search admin subcommand under the plugin namespace. */
+export function configureMemorySearchCommand(
+  parent: Command,
+  junior: PluginCliHost,
+): void {
+  parent
+    .command("search")
+    .description("Search visible memories")
+    .argument("[query...]", "Search query")
+    .addOption(
+      new Option("--scope <scope>", "Memory scope")
+        .choices([...MEMORY_SCOPES])
+        .makeOptionMandatory(),
+    )
+    .requiredOption("--scope-key <key>", "Scope key")
+    .addOption(
+      new Option("--limit <n>", "Maximum rows")
+        .argParser(parseLimit)
+        .default(20),
+    )
+    .option("--show-content", "Print raw memory content")
+    .action(
+      junior.action(async (ctx, queryParts, options) => {
+        return await runSearch(
+          ctx,
+          queryParts as string[] | undefined,
+          options as SearchOptions,
+        );
+      }),
+    );
+}

package/src/cli/show.ts

@@ -0,0 +1,44 @@
+import type { Command } from "commander";
+import type {
+  PluginCliActionContext,
+  PluginCliHost,
+} from "@sentry/junior-plugin-api";
+import { eq } from "drizzle-orm";
+import { juniorMemoryMemories } from "../db/schema";
+import type { MemoryDb } from "../store";
+import { formatMemory } from "./format";
+
+async function runShow(
+  ctx: PluginCliActionContext,
+  id: string,
+): Promise<number> {
+  const db = ctx.db as MemoryDb;
+  const rows = await db
+    .select()
+    .from(juniorMemoryMemories)
+    .where(eq(juniorMemoryMemories.id, id))
+    .limit(1);
+  if (!rows[0]) {
+    await ctx.io.writeError(`Memory not found: ${id}\n`);
+    return 1;
+  }
+
+  await ctx.io.writeOutput(`${formatMemory(rows[0], { showContent: true })}\n`);
+  return 0;
+}
+
+/** Wire the explicit raw-content memory inspection subcommand. */
+export function configureMemoryShowCommand(
+  parent: Command,
+  junior: PluginCliHost,
+): void {
+  parent
+    .command("show")
+    .description("Show one memory")
+    .argument("<id>", "Memory id")
+    .action(
+      junior.action(async (ctx, id) => {
+        return await runShow(ctx, id as string);
+      }),
+    );
+}