@chorus-aidlc/chorus-openclaw-plugin 0.4.0 → 0.5.3

package/src/commands.ts

@@ -1,97 +1,158 @@
 import type { ChorusMcpClient } from "./mcp-client.js";
 
 // ===== Response types from Chorus MCP tools =====
-
-interface CheckinResponse {
-  checkinTime: string;
-  agent: {
-    uuid: string;
-    name: string;
-    roles: string[];
-    persona: string | null;
-    systemPrompt: string | null;
-  };
-  assignments: {
-    ideas: AssignedIdea[];
-    tasks: AssignedTask[];
-  };
-  pending: {
-    ideasCount: number;
-    tasksCount: number;
-  };
-  notifications: {
-    unreadCount: number;
-  };
-}
-
-interface AssignedIdea {
+//
+// These mirror the CURRENT (Chorus 0.7.2+) tool output shapes:
+//   - chorus_checkin           → { checkinTime, agent, ideaTracker, notifications }
+//   - chorus_get_my_assignments → { ideaTracker, taskTracker }
+// Both `ideaTracker` and `taskTracker` are Records keyed by project UUID, with
+// the work items nested inside each project bucket. Every field is read
+// defensively (optional chaining) so a missing/renamed field degrades to "0"
+// or "none" rather than throwing.
+
+interface IdeaTrackerEntry {
   uuid: string;
   title: string;
   status: string;
-  project: { uuid: string; name: string };
+  proposals?: number;
+  tasks?: number;
 }
 
-interface AssignedTask {
+interface TaskTrackerEntry {
   uuid: string;
   title: string;
   status: string;
   priority: string;
-  project: { uuid: string; name: string };
+  ac?: { passed?: number; total?: number };
+}
+
+interface IdeaTrackerProject {
+  name: string;
+  ideas?: IdeaTrackerEntry[];
+}
+
+interface TaskTrackerProject {
+  name: string;
+  tasks?: TaskTrackerEntry[];
+}
+
+interface CheckinResponse {
+  checkinTime?: string;
+  agent?: {
+    uuid?: string;
+    name?: string;
+    persona?: string | null;
+  };
+  ideaTracker?: Record<string, IdeaTrackerProject>;
+  notifications?: {
+    unread?: number;
+  };
 }
 
 interface AssignmentsResponse {
-  ideas: AssignedIdea[];
-  tasks: AssignedTask[];
+  ideaTracker?: Record<string, IdeaTrackerProject>;
+  taskTracker?: Record<string, TaskTrackerProject>;
 }
 
-// ===== Formatting helpers =====
+// ===== Skill catalog =====
+//
+// All 9 skills bundled with the Chorus OpenClaw plugin
+// (packages/openclaw-plugin/skills/*/SKILL.md). The `name` here matches each
+// skill's SKILL.md frontmatter `name`, which is exactly the slash command
+// OpenClaw exposes (see invocation hint below).
 
 const PLUGIN_SKILLS = [
-  { name: "chorus", emoji: "🎵", description: "Platform overview, tools, setup, and workflow routing" },
-  { name: "idea", emoji: "💡", description: "Claim ideas, run elaboration, prepare for proposal" },
-  { name: "proposal", emoji: "📋", description: "Create proposals with document & task drafts, manage DAG" },
-  { name: "develop", emoji: "🔨", description: "Claim tasks, report work, submit for verification" },
-  { name: "quick-dev", emoji: "⚡", description: "Skip Idea→Proposal, create tasks directly" },
-  { name: "review", emoji: "✅", description: "Approve/reject proposals, verify tasks, governance" },
+  { name: "chorus", description: "Platform overview, common tools, setup, and workflow routing" },
+  { name: "idea", description: "Claim ideas, run elaboration rounds, prepare for proposal" },
+  { name: "brainstorm", description: "Optional divergent-then-convergent dialogue for fuzzy ideas" },
+  { name: "proposal", description: "Create proposals with document & task drafts, manage the dependency DAG" },
+  { name: "develop", description: "Claim tasks, report work, manage sessions, run wave-based execution" },
+  { name: "quick-dev", description: "Skip Idea→Proposal — create tasks directly, execute, verify" },
+  { name: "review", description: "Approve/reject proposals, verify tasks, project governance" },
+  { name: "yolo", description: "Full-auto AI-DLC pipeline — from prompt to done" },
+  { name: "openspec-aware", description: "Opt-in OpenSpec authoring for PM workflows when the openspec CLI is present" },
 ] as const;
 
+// ===== Formatting helpers =====
+
+// OpenClaw invokes a skill via a BARE slash command of its SKILL.md `name`
+// (verified against OpenClaw 2026.5.30 docs/tools/skills.md: "the skill's
+// visible name, slash command ... come from SKILL.md frontmatter name ... a
+// nested skill with name: research is still invoked as /research"). OpenClaw
+// does NOT use Claude Code's `/chorus:<skill>` namespace form.
+function skillInvocation(name: string): string {
+  return `/${name}`;
+}
+
 function formatSkillsList(): string {
+  const nameWidth = Math.max(...PLUGIN_SKILLS.map((s) => skillInvocation(s.name).length));
   const lines = PLUGIN_SKILLS.map(
-    (s) => `  ${s.emoji} ${s.name.padEnd(12)} ${s.description}`
+    (s) => `  ${skillInvocation(s.name).padEnd(nameWidth)}  ${s.description}`
   );
-  return `Chorus skills (${PLUGIN_SKILLS.length}):\n${lines.join("\n")}\n\nUse: /chorus:<skill-name>  (e.g. /chorus:idea)`;
+  return [
+    `Chorus skills (${PLUGIN_SKILLS.length}):`,
+    ...lines,
+    "",
+    "Invoke a skill with its slash command, e.g. /develop or /idea.",
+  ].join("\n");
+}
+
+// Sum a count across every project bucket in a tracker Record.
+function countTracker<T>(
+  tracker: Record<string, { ideas?: T[]; tasks?: T[] }> | undefined,
+  key: "ideas" | "tasks"
+): number {
+  if (!tracker) return 0;
+  return Object.values(tracker).reduce((total, project) => {
+    const items = key === "ideas" ? project.ideas : project.tasks;
+    return total + (items?.length ?? 0);
+  }, 0);
 }
 
 function formatStatus(checkin: CheckinResponse, connectionStatus: string): string {
+  const ideaCount = countTracker(checkin?.ideaTracker, "ideas");
   const lines: string[] = [
     `Connection: ${connectionStatus}`,
-    `Assignments: ${checkin?.pending?.ideasCount ?? 0} ideas, ${checkin?.pending?.tasksCount ?? 0} tasks`,
-    `Notifications: ${checkin?.notifications?.unreadCount ?? 0} unread`,
+    `Agent: ${checkin?.agent?.name ?? "unknown"}`,
+    `Assigned ideas: ${ideaCount}`,
+    `Notifications: ${checkin?.notifications?.unread ?? 0} unread`,
     `Skills: ${PLUGIN_SKILLS.map((s) => s.name).join(", ")}`,
   ];
   return lines.join("\n");
 }
 
-function formatTaskList(tasks: AssignedTask[] | undefined): string {
-  if (!tasks?.length) {
+function formatTaskList(taskTracker: Record<string, TaskTrackerProject> | undefined): string {
+  const lines: string[] = [];
+  let total = 0;
+  for (const project of Object.values(taskTracker ?? {})) {
+    for (const t of project.tasks ?? []) {
+      total += 1;
+      const ac =
+        t.ac && typeof t.ac.total === "number" && t.ac.total > 0
+          ? ` (AC ${t.ac.passed ?? 0}/${t.ac.total})`
+          : "";
+      lines.push(`[${t.status}] [${t.priority}] ${t.title}  (${project.name})${ac}`);
+    }
+  }
+  if (total === 0) {
     return "No assigned tasks.";
   }
-
-  const lines = tasks.map(
-    (t) => `[${t.status}] [${t.priority}] ${t.title}  (${t.project.name})`
-  );
-  return `Assigned tasks (${tasks.length}):\n${lines.join("\n")}`;
+  return `Assigned tasks (${total}):\n${lines.join("\n")}`;
 }
 
-function formatIdeaList(ideas: AssignedIdea[] | undefined): string {
-  if (!ideas?.length) {
+function formatIdeaList(ideaTracker: Record<string, IdeaTrackerProject> | undefined): string {
+  const lines: string[] = [];
+  let total = 0;
+  for (const project of Object.values(ideaTracker ?? {})) {
+    for (const i of project.ideas ?? []) {
+      total += 1;
+      lines.push(`[${i.status}] ${i.title}  (${project.name})`);
+    }
+  }
+  if (total === 0) {
     return "No assigned ideas.";
   }
-
-  const lines = ideas.map(
-    (i) => `[${i.status}] ${i.title}  (${i.project.name})`
-  );
-  return `Assigned ideas (${ideas.length}):\n${lines.join("\n")}`;
+  return `Assigned ideas (${total}):\n${lines.join("\n")}`;
 }
 
 const HELP_TEXT = [
@@ -103,61 +164,67 @@ const HELP_TEXT = [
   "  /chorus skills    List available Chorus skills",
 ].join("\n");
 
+function errorText(prefix: string, err: unknown): string {
+  const detail = err instanceof Error ? err.message : String(err);
+  return `${prefix}: ${detail}`;
+}
+
 // ===== Registration =====
 
 export function registerChorusCommands(
-  api: any,
+  api: { registerCommand: (command: unknown) => void },
   mcpClient: ChorusMcpClient,
   getStatus: () => string
 ): void {
   api.registerCommand({
     name: "chorus",
-    description: "Chorus plugin commands: status, tasks, ideas",
-    async handler(ctx: { args: string }) {
+    description: "Chorus plugin commands: status, tasks, ideas, skills",
+    acceptsArgs: true,
+    async handler(ctx: { args?: string }) {
       const sub = (ctx.args ?? "").trim().toLowerCase();
 
-      // /chorus or /chorus status
+      // /chorus or /chorus status — connection + checkin summary via slim client.
       if (!sub || sub === "status") {
         try {
           const checkin = (await mcpClient.callTool("chorus_checkin", {})) as CheckinResponse;
           return { text: formatStatus(checkin, getStatus()) };
         } catch (err) {
-          return { text: `Failed to check in: ${err instanceof Error ? err.message : String(err)}` };
+          return { text: errorText("Failed to check in", err), isError: true };
         }
       }
 
-      // /chorus tasks
+      // /chorus tasks — assigned tasks via chorus_get_my_assignments.
       if (sub === "tasks") {
         try {
           const data = (await mcpClient.callTool(
             "chorus_get_my_assignments",
             {}
           )) as AssignmentsResponse;
-          return { text: formatTaskList(data?.tasks) };
+          return { text: formatTaskList(data?.taskTracker) };
         } catch (err) {
-          return { text: `Failed to fetch tasks: ${err instanceof Error ? err.message : String(err)}` };
+          return { text: errorText("Failed to fetch tasks", err), isError: true };
         }
       }
 
-      // /chorus skills
-      if (sub === "skills") {
-        return { text: formatSkillsList() };
-      }
-
-      // /chorus ideas
+      // /chorus ideas — assigned ideas via chorus_get_my_assignments.
       if (sub === "ideas") {
         try {
           const data = (await mcpClient.callTool(
             "chorus_get_my_assignments",
             {}
           )) as AssignmentsResponse;
-          return { text: formatIdeaList(data?.ideas) };
+          return { text: formatIdeaList(data?.ideaTracker) };
         } catch (err) {
-          return { text: `Failed to fetch ideas: ${err instanceof Error ? err.message : String(err)}` };
+          return { text: errorText("Failed to fetch ideas", err), isError: true };
         }
       }
 
-      // Unknown subcommand
+      // /chorus skills — static catalog of all 9 bundled skills.
+      if (sub === "skills") {
+        return { text: formatSkillsList() };
+      }
+
+      // Unknown subcommand → help.
       return { text: HELP_TEXT };
     },
   });

package/src/config.ts

@@ -3,6 +3,15 @@ import { z } from "zod";
 export const CONFIG_FILE_PATH = "~/.openclaw/openclaw.json";
 export const CONFIG_KEY_PATH = "plugins.entries.chorus-openclaw-plugin.config";
 
+/**
+ * In-code zod schema for typing `api.pluginConfig`.
+ *
+ * The canonical config contract is the JSON-Schema `configSchema` in
+ * `openclaw.plugin.json`, which OpenClaw validates BEFORE plugin code runs.
+ * This zod schema exists only for in-code typing and friendly missing-field
+ * messages — its accepted property set (chorusUrl, apiKey) MUST stay identical
+ * to the manifest `configSchema.properties`.
+ */
 export const chorusConfigSchema = z.object({
   chorusUrl: z
     .string()
@@ -14,20 +23,24 @@ export const chorusConfigSchema = z.object({
     .startsWith("cho_")
     .optional()
     .describe("Chorus API Key (cho_ prefix)"),
-  projectUuids: z
-    .array(z.string().uuid())
-    .optional()
-    .default([])
-    .describe("Project UUIDs to monitor. Empty = all projects"),
-  autoStart: z
-    .boolean()
-    .optional()
-    .default(true)
-    .describe("Auto-claim and start work on task_assigned events"),
 });
 
 export type ChorusPluginConfig = z.infer<typeof chorusConfigSchema>;
 
+/**
+ * Normalize a raw `api.pluginConfig` bag into a typed `ChorusPluginConfig`.
+ *
+ * The host has already validated the bag against the manifest JSON Schema, so
+ * this only fills defaults and narrows types; it does not re-validate shape.
+ */
+export function resolveConfig(pluginConfig: Record<string, unknown> | undefined): ChorusPluginConfig {
+  const raw = pluginConfig ?? {};
+  return {
+    chorusUrl: (raw.chorusUrl as string | undefined) || undefined,
+    apiKey: (raw.apiKey as string | undefined) || undefined,
+  };
+}
+
 /**
  * Check required config fields and warn about missing ones.
  * Returns true if all required fields are present, false otherwise.

package/src/event-router.ts

@@ -1,11 +1,21 @@
 import type { ChorusMcpClient } from "./mcp-client.js";
-import type { ChorusPluginConfig } from "./config.js";
 import type { SseNotificationEvent } from "./sse-listener.js";
 
+/**
+ * Wake callback injected by the entry. Runs an embedded agent turn on the main
+ * agent's session with `message` as the prompt (see `wake.ts` → createWake,
+ * which calls `api.runtime.agent.runEmbeddedAgent`).
+ *
+ * `contextKey` identifies the originating Chorus action+entity (e.g.
+ * `chorus:mentioned:<uuid>`); it is used for the run id / logging. The wake
+ * resolves the main agent session + model and DROPS (logs + returns) when it
+ * cannot run — it never throws, so the SSE service stays alive.
+ */
+export type ChorusWakeFn = (message: string, contextKey: string) => void;
+
 export interface ChorusEventRouterOptions {
   mcpClient: ChorusMcpClient;
-  config: ChorusPluginConfig;
-  triggerAgent: (message: string, metadata?: Record<string, unknown>) => void;
+  wake: ChorusWakeFn;
   logger: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void };
 }
 
@@ -28,17 +38,13 @@ interface NotificationDetail {
 
 export class ChorusEventRouter {
   private readonly mcpClient: ChorusMcpClient;
-  private readonly config: ChorusPluginConfig;
-  private readonly triggerAgent: ChorusEventRouterOptions["triggerAgent"];
+  private readonly wake: ChorusWakeFn;
   private readonly logger: ChorusEventRouterOptions["logger"];
-  private readonly projectFilter: Set<string>;
 
   constructor(opts: ChorusEventRouterOptions) {
     this.mcpClient = opts.mcpClient;
-    this.config = opts.config;
-    this.triggerAgent = opts.triggerAgent;
+    this.wake = opts.wake;
     this.logger = opts.logger;
-    this.projectFilter = new Set(opts.config.projectUuids ?? []);
   }
 
   /**
@@ -67,6 +73,15 @@ export class ChorusEventRouter {
   // Internal
   // ---------------------------------------------------------------------------
 
+  /**
+   * Build the dedupe contextKey for a notification. Identical action+entity
+   * bursts collapse to the same key so OpenClaw's queue suppresses the
+   * duplicate wake.
+   */
+  private contextKeyFor(action: string, entityUuid: string): string {
+    return `chorus:${action}:${entityUuid}`;
+  }
+
   private async fetchAndRoute(notificationUuid: string): Promise<void> {
     // Fetch notification details via MCP — use autoMarkRead=false so we don't
     // consume all unread notifications, and status=unread since we just received it
@@ -88,19 +103,11 @@ export class ChorusEventRouter {
       return;
     }
 
-    // Project filter: if projectUuids is configured, ignore events from other projects
-    if (this.projectFilter.size > 0 && !this.projectFilter.has(notification.projectUuid)) {
-      this.logger.info(
-        `Notification for project ${notification.projectUuid} filtered out`
-      );
-      return;
-    }
-
     // Route based on action (which corresponds to notificationType)
     try {
       switch (notification.action) {
         case "task_assigned":
-          await this.handleTaskAssigned(notification);
+          this.handleTaskAssigned(notification);
           break;
         case "mentioned":
           this.handleMentioned(notification);
@@ -146,57 +153,42 @@ export class ChorusEventRouter {
     );
   }
 
-  private async handleTaskAssigned(n: NotificationDetail): Promise<void> {
+  private handleTaskAssigned(n: NotificationDetail): void {
     const mentionGuidance = this.buildMentionGuidance(n, "task");
 
-    if (this.config.autoStart) {
-      try {
-        await this.mcpClient.callTool("chorus_claim_task", { taskUuid: n.entityUuid });
-        this.logger.info(`Auto-claimed task ${n.entityUuid}`);
-      } catch (err) {
-        this.logger.warn(`Failed to auto-claim task ${n.entityUuid}: ${err}`);
-        // Still trigger agent even if claim fails — let the agent handle it
-      }
-
-      this.triggerAgent(
-        `[Chorus] Task assigned: ${n.entityTitle}. Task UUID: ${n.entityUuid}, Project UUID: ${n.projectUuid}. Use chorus_get_task to see details and begin work.\n${mentionGuidance}`,
-        { notificationUuid: n.uuid, action: "task_assigned", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
-      );
-    } else {
-      this.triggerAgent(
-        `[Chorus] Task assigned: ${n.entityTitle}. Task UUID: ${n.entityUuid}, Project UUID: ${n.projectUuid}. Use chorus_get_task to review when ready.\n${mentionGuidance}`,
-        { notificationUuid: n.uuid, action: "task_assigned", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
-      );
-    }
+    this.wake(
+      `[Chorus] Task assigned: ${n.entityTitle}. Task UUID: ${n.entityUuid}, Project UUID: ${n.projectUuid}. Use chorus_get_task to review the task, then chorus_claim_task to start work.\n${mentionGuidance}`,
+      this.contextKeyFor("task_assigned", n.entityUuid)
+    );
   }
 
   private handleMentioned(n: NotificationDetail): void {
     const mentionGuidance = this.buildMentionGuidance(n, n.entityType);
 
-    this.triggerAgent(
+    this.wake(
       `[Chorus] You were @mentioned in ${n.entityType} '${n.entityTitle}' (entityType: ${n.entityType}, entityUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}): ${n.message}\n` +
       `Review the ${n.entityType} content and use chorus_get_comments (targetType: "${n.entityType}", targetUuid: "${n.entityUuid}") to see the full conversation, then respond.\n` +
       mentionGuidance,
-      { notificationUuid: n.uuid, action: "mentioned", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      this.contextKeyFor("mentioned", n.entityUuid)
     );
   }
 
   private handleElaborationRequested(n: NotificationDetail): void {
-    this.triggerAgent(
+    this.wake(
       `[Chorus] Elaboration requested for idea '${n.entityTitle}' (ideaUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). Use chorus_get_elaboration to review questions.`,
-      { notificationUuid: n.uuid, action: "elaboration_requested", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      this.contextKeyFor("elaboration_requested", n.entityUuid)
     );
   }
 
   private handleProposalRejected(n: NotificationDetail): void {
     const mentionGuidance = this.buildMentionGuidance(n, "proposal");
 
-    this.triggerAgent(
+    this.wake(
       `[Chorus] Proposal '${n.entityTitle}' was REJECTED (proposalUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). Review note: "${n.message}". ` +
       `Use chorus_get_proposal to review the proposal, then fix issues with chorus_update_task_draft / chorus_update_document_draft. ` +
       `After fixing, call chorus_validate_proposal then chorus_submit_proposal to resubmit.\n` +
       mentionGuidance,
-      { notificationUuid: n.uuid, action: "proposal_rejected", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      this.contextKeyFor("proposal_rejected", n.entityUuid)
     );
   }
 
@@ -204,54 +196,54 @@ export class ChorusEventRouter {
     const mentionGuidance = this.buildMentionGuidance(n, "proposal");
 
     const reviewInfo = n.message.includes("Note: ") ? ` Review note: "${n.message.split("Note: ").pop()}"` : "";
-    this.triggerAgent(
+    this.wake(
       `[Chorus] Proposal '${n.entityTitle}' was APPROVED (proposalUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid})!${reviewInfo} Documents and tasks have been created. ` +
       `Use chorus_get_available_tasks with projectUuid: "${n.projectUuid}" to see the new tasks ready for work.\n` +
       mentionGuidance,
-      { notificationUuid: n.uuid, action: "proposal_approved", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      this.contextKeyFor("proposal_approved", n.entityUuid)
     );
   }
 
   private handleIdeaClaimed(n: NotificationDetail): void {
     const mentionGuidance = this.buildMentionGuidance(n, "idea");
 
-    this.triggerAgent(
+    this.wake(
       `[Chorus] Idea '${n.entityTitle}' has been assigned to you (ideaUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). ` +
       `Use chorus_get_idea to review the idea, then chorus_claim_idea to start elaboration.\n` +
       mentionGuidance,
-      { notificationUuid: n.uuid, action: "idea_claimed", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      this.contextKeyFor("idea_claimed", n.entityUuid)
     );
   }
 
   private handleTaskVerified(n: NotificationDetail): void {
-    this.triggerAgent(
+    this.wake(
       `[Chorus] Task '${n.entityTitle}' has been verified and is now done (taskUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). ` +
       `Check if this unblocks other tasks: use chorus_get_unblocked_tasks with projectUuid "${n.projectUuid}" to find tasks that are now ready to start.`,
-      { notificationUuid: n.uuid, action: "task_verified", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      this.contextKeyFor("task_verified", n.entityUuid)
     );
   }
 
   private handleTaskReopened(n: NotificationDetail): void {
     const mentionGuidance = this.buildMentionGuidance(n, "task");
 
-    this.triggerAgent(
+    this.wake(
       `[Chorus] Task '${n.entityTitle}' has been reopened and needs rework (taskUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). ` +
       `Use chorus_get_task to review the task and chorus_get_comments to see verification feedback, then fix the issues.\n${mentionGuidance}`,
-      { notificationUuid: n.uuid, action: "task_reopened", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      this.contextKeyFor("task_reopened", n.entityUuid)
     );
   }
 
   private handleElaborationAnswered(n: NotificationDetail): void {
     const mentionGuidance = this.buildMentionGuidance(n, "idea");
 
-    this.triggerAgent(
+    this.wake(
       `[Chorus] Elaboration answers submitted for idea '${n.entityTitle}' (ideaUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). ` +
       `Review the answers with chorus_get_elaboration, then either:\n` +
       `- Call chorus_validate_elaboration with empty issues [] to resolve and proceed to proposal creation\n` +
       `- Call chorus_validate_elaboration with issues + followUpQuestions for another round\n\n` +
       `After reviewing, @mention the answerer to ask if they have any further questions before you proceed.\n` +
       mentionGuidance,
-      { notificationUuid: n.uuid, action: "elaboration_answered", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      this.contextKeyFor("elaboration_answered", n.entityUuid)
     );
   }
 }