@chorus-aidlc/chorus-openclaw-plugin 0.10.0 → 0.11.0

package/src/daemon-rest-client.ts

@@ -0,0 +1,312 @@
+// packages/openclaw-plugin/src/daemon-rest-client.ts
+// TypeScript mirror of the shared, host-agnostic pure-REST client for the Chorus
+// daemon → server reporting surface (`/api/daemon/*`).
+//
+// WHY A MIRROR (not an import): the single-source-of-truth implementation is
+// `cli/daemon-rest-client.mjs`, consumed verbatim by the chorus CLI daemon. The
+// OpenClaw plugin, however, is a SEPARATELY-PUBLISHED npm package
+// (`@chorus-aidlc/chorus-openclaw-plugin`, `files: ["src", "dist", ...]`) whose
+// TS build has `rootDir: "src"`. Importing a file under `cli/` (outside both the
+// package boundary AND rootDir) is rejected by `tsc` and would not be present in
+// the published tarball. So we mirror the EXACT same factory + payload shapes here
+// — this is NOT a fork of the wire contract: every payload below is byte-for-byte
+// the shape `cli/daemon-rest-client.mjs` sends (and the server already accepts).
+// The two files are kept in lock-step by the spec's "single source of truth for
+// the payload shapes" requirement; a drift would be caught by T5 (live e2e).
+//
+// The five operations and their EXACT server payload shapes (verified against
+// cli/daemon-rest-client.mjs + src/app/api/daemon/*/route.ts — server unchanged):
+//   turnAdvance      → POST /api/daemon/turn-advance
+//                      { connectionUuid, sessionId, status, entityType?, entityUuid? }
+//   transcript       → POST /api/daemon/transcript
+//                      { sessionId, messages: [{ role, text }] }
+//   executionState   → POST /api/daemon/execution-state
+//                      { connectionUuid, executions: [{ entityType, entityUuid,
+//                                                       rootIdeaUuid|null, status,
+//                                                       startedAt|null }] }
+//   reportInterrupt  → POST /api/daemon/report-interrupt
+//                      { connectionUuid, entityType, entityUuid, reason }
+//   readPendingTurns → GET  /api/daemon/pending-turns?connectionUuid=…
+//                      → { turns: [{ turnUuid, sessionId, directIdeaUuid, trigger,
+//                                    promptText }] }
+//
+// HARD CONSTRAINTS (identical to the CLI client):
+//   • ZERO daemon-host coupling — no child_process, no OpenClaw SDK import. Its only
+//     outbound effect is HTTP via the injected `fetchImpl` (global fetch on Node 18+).
+//     Adds NO new npm dependency (CLAUDE.md pitfall #9).
+//   • Bearer-only auth: every request carries `Authorization: Bearer <apiKey>`.
+//   • NO SILENT ERRORS (project policy): a network error, a non-2xx response, or a
+//     bad/empty body is LOGGED WITH ITS CAUSE and SURFACED via a structured result —
+//     never swallowed into a silent success.
+//   • A failed report NEVER rejects: every method RESOLVES with `{ ok: false, ... }`
+//     so a fire-and-forget caller can `await` it safely.
+
+export interface DaemonRestLogger {
+  info: (msg: string) => void;
+  warn: (msg: string) => void;
+  error: (msg: string) => void;
+}
+
+const NOOP_LOGGER: DaemonRestLogger = { info() {}, warn() {}, error() {} };
+
+/** A single transcript message — only `role` + visible `text` (no internals). */
+export interface DaemonTranscriptMessage {
+  role: "user" | "assistant";
+  text: string;
+}
+
+/** One execution-snapshot row, in the server's exact `execution-state` shape. */
+export interface DaemonExecutionRow {
+  entityType: string;
+  entityUuid: string;
+  rootIdeaUuid: string | null;
+  status: "running" | "queued";
+  startedAt: string | null;
+}
+
+/** One unstarted (pending) turn read back from the turn table. */
+export interface DaemonPendingTurn {
+  turnUuid: string;
+  sessionId: string;
+  directIdeaUuid: string | null;
+  trigger: string;
+  promptText: string | null;
+}
+
+/**
+ * Structured result of every client call. Mirrors the CLI client's
+ * `DaemonRestResult`: `ok` is true only on a 2xx (and, for reads, a well-formed
+ * body); `error` carries the (also-logged) failure cause; `skipped` marks an
+ * intentional non-call (e.g. no connection uuid yet); `data` holds parsed read
+ * payloads.
+ */
+export interface DaemonRestResult<TData = unknown> {
+  ok: boolean;
+  status: number | null;
+  error?: string;
+  skipped?: boolean;
+  data?: TData;
+}
+
+export interface CreateDaemonRestClientOptions {
+  /** Chorus base URL (a trailing slash is normalized away). */
+  url: string;
+  /** `cho_` agent API key for Bearer auth. */
+  apiKey: string;
+  /**
+   * The daemon's registered connection uuid (learned from the SSE handshake),
+   * read LAZILY on every call so construction order does not matter. The
+   * connection-scoped operations (turnAdvance, executionState, reportInterrupt,
+   * readPendingTurns) require it; a null value skips the call (logged where the
+   * skip is unexpected, silent where it is a normal early state).
+   */
+  getConnectionUuid?: () => string | null;
+  /** Injectable for tests (defaults to global fetch). */
+  fetchImpl?: typeof fetch;
+  logger?: DaemonRestLogger;
+}
+
+export interface DaemonRestClient {
+  turnAdvance(p: {
+    sessionId: string;
+    status: "running" | "ended";
+    entityType?: string | null;
+    entityUuid?: string | null;
+  }): Promise<DaemonRestResult>;
+  transcript(p: {
+    sessionId: string;
+    messages: DaemonTranscriptMessage[];
+  }): Promise<DaemonRestResult>;
+  executionState(p: { executions: DaemonExecutionRow[] }): Promise<DaemonRestResult>;
+  reportInterrupt(p: {
+    entityType: string;
+    entityUuid: string;
+    reason: "user" | "crash";
+  }): Promise<DaemonRestResult>;
+  readPendingTurns(): Promise<DaemonRestResult<{ turns: DaemonPendingTurn[] }>>;
+}
+
+/**
+ * Build the shared daemon REST client. Inputs are entirely host-agnostic, which is
+ * exactly why the same surface serves both daemon hosts.
+ */
+export function createDaemonRestClient(opts: CreateDaemonRestClientOptions): DaemonRestClient {
+  const url = opts.url.replace(/\/$/, "");
+  const apiKey = opts.apiKey;
+  const getConnectionUuid = opts.getConnectionUuid ?? (() => null);
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const logger = opts.logger ?? NOOP_LOGGER;
+
+  const jsonHeaders = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  };
+
+  /**
+   * Issue one daemon report. Owns the transport + the no-silent-errors contract
+   * IDENTICAL across all four POST endpoints; only the `op` label and the path
+   * differ. Never throws — returns a structured {@link DaemonRestResult}.
+   */
+  async function post(
+    op: string,
+    path: string,
+    body: unknown,
+    successLog?: string,
+    context = "",
+  ): Promise<DaemonRestResult> {
+    let response: Response;
+    try {
+      response = await fetchImpl(`${url}${path}`, {
+        method: "POST",
+        headers: jsonHeaders,
+        body: JSON.stringify(body),
+      });
+    } catch (err) {
+      // Network-level failure (DNS, connection refused, abort, …). Surface WITH cause.
+      const error = `${op} request failed${context}: ${err}`;
+      logger.warn(`[Chorus] ${error}`);
+      return { ok: false, status: null, error };
+    }
+    if (!response.ok) {
+      // Non-2xx. Surface WITH the status so a 4xx/5xx is debuggable.
+      const error = `${op} returned ${response.status}${context}`;
+      logger.warn(`[Chorus] ${error}`);
+      return { ok: false, status: response.status, error };
+    }
+    if (successLog) logger.info(`[Chorus] ${successLog}`);
+    return { ok: true, status: response.status };
+  }
+
+  return {
+    /**
+     * POST /api/daemon/turn-advance — advance a wake's DaemonSessionTurn lifecycle.
+     * The server resolves the turn by the session BUSINESS KEY (`sessionId`); the
+     * optional `entityType`/`entityUuid` stamp the weak executionUuid link. Requires
+     * the connectionUuid.
+     */
+    async turnAdvance({ sessionId, status, entityType, entityUuid }) {
+      const connectionUuid = getConnectionUuid();
+      if (!connectionUuid) {
+        const error = `cannot advance turn for session ${sessionId} → ${status} — no connection uuid yet`;
+        logger.warn(`[Chorus] ${error}`);
+        return { ok: false, status: null, error, skipped: true };
+      }
+      const body = {
+        connectionUuid,
+        sessionId,
+        status,
+        // Only sent when BOTH are present, so the server never gets a partial linkage.
+        ...(entityType && entityUuid ? { entityType, entityUuid } : {}),
+      };
+      return post(
+        "turn-advance",
+        "/api/daemon/turn-advance",
+        body,
+        `advanced turn for session ${sessionId} → ${status}`,
+      );
+    },
+
+    /**
+     * POST /api/daemon/transcript — append finalized user/assistant text to the
+     * current turn, targeted by the session BUSINESS KEY. The caller owns the content
+     * filter (only `{ role, text }`) and any batching. No connectionUuid needed.
+     */
+    async transcript({ sessionId, messages }) {
+      return post(
+        "transcript upload",
+        "/api/daemon/transcript",
+        { sessionId, messages },
+        `transcript uploaded (${messages.length} msg) for session ${sessionId}`,
+      );
+    },
+
+    /**
+     * POST /api/daemon/execution-state — publish the connection's running/queued
+     * execution snapshot (caller supplies the already-built `executions` array).
+     * Requires the connectionUuid; a null uuid is a normal early state (silent skip).
+     */
+    async executionState({ executions }) {
+      const connectionUuid = getConnectionUuid();
+      if (!connectionUuid) {
+        return { ok: false, status: null, skipped: true };
+      }
+      return post(
+        "execution-state upload",
+        "/api/daemon/execution-state",
+        { connectionUuid, executions },
+        `execution-state uploaded (${executions.length} active)`,
+      );
+    },
+
+    /**
+     * POST /api/daemon/report-interrupt — record a wake's `interrupted` outcome
+     * (reason = "user" | "crash") on the execution row keyed by connection + entity.
+     */
+    async reportInterrupt({ entityType, entityUuid, reason }) {
+      const connectionUuid = getConnectionUuid();
+      if (!connectionUuid) {
+        const error = `cannot report interrupt for ${entityType}:${entityUuid} — no connection uuid yet`;
+        logger.warn(`[Chorus] ${error}`);
+        return { ok: false, status: null, error, skipped: true };
+      }
+      return post(
+        "report-interrupt",
+        "/api/daemon/report-interrupt",
+        { connectionUuid, entityType, entityUuid, reason },
+        `reported ${entityType}:${entityUuid} interrupted (reason=${reason})`,
+        ` for ${entityType}:${entityUuid}`,
+      );
+    },
+
+    /**
+     * GET /api/daemon/pending-turns?connectionUuid=… — read this connection's
+     * unstarted (pending) turns. Returns the parsed `{ turns: [...] }` data on
+     * success; a network error / non-2xx / bad body / missing array is logged with
+     * cause and surfaced as a failure result — never a silent empty success.
+     */
+    async readPendingTurns() {
+      const connectionUuid = getConnectionUuid();
+      if (!connectionUuid) {
+        return { ok: false, status: null, skipped: true };
+      }
+      const endpoint = `${url}/api/daemon/pending-turns?connectionUuid=${encodeURIComponent(connectionUuid)}`;
+      let response: Response;
+      try {
+        response = await fetchImpl(endpoint, {
+          headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+        });
+      } catch (err) {
+        const error = `pending-turns backfill request failed: ${err}`;
+        logger.warn(`[Chorus] ${error}`);
+        return { ok: false, status: null, error };
+      }
+      if (!response.ok) {
+        const error = `pending-turns backfill returned ${response.status}`;
+        logger.warn(`[Chorus] ${error}`);
+        return { ok: false, status: response.status, error };
+      }
+      let parsed: unknown;
+      try {
+        parsed = await response.json();
+      } catch (err) {
+        const error = `pending-turns backfill: bad JSON: ${err}`;
+        logger.warn(`[Chorus] ${error}`);
+        return { ok: false, status: response.status, error };
+      }
+      // API envelope: { success: true, data: { turns: [...] } }.
+      const data =
+        parsed && typeof parsed === "object"
+          ? (parsed as { data?: unknown }).data
+          : undefined;
+      const turns =
+        data && typeof data === "object" ? (data as { turns?: unknown }).turns : undefined;
+      if (!Array.isArray(turns)) {
+        const error = "pending-turns backfill: no turns array in response";
+        logger.warn(`[Chorus] ${error}`);
+        return { ok: false, status: response.status, error };
+      }
+      return { ok: true, status: response.status, data: { turns: turns as DaemonPendingTurn[] } };
+    },
+  };
+}

package/src/event-router.ts

@@ -1,21 +1,50 @@
 import type { ChorusMcpClient } from "./mcp-client.js";
 import type { SseNotificationEvent } from "./sse-listener.js";
+import type { LineageResolver } from "./lineage.js";
+
+/**
+ * Per-wake attribution the router resolves and threads to the wake. Carries the
+ * reportable resource (`entityType`/`entityUuid`) and the lineage ids (the two-id
+ * contract: `directIdeaUuid` = session anchor, `rootIdeaUuid` = snapshot attribution).
+ * All optional so a host wired WITHOUT the daemon client (no lineage) still wakes —
+ * the daemon-reporting fields are simply absent and the run is a plain wake.
+ */
+export interface WakeAttribution {
+  entityType?: string | null;
+  entityUuid?: string | null;
+  directIdeaUuid?: string | null;
+  rootIdeaUuid?: string | null;
+}
 
 /**
  * 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`).
+ * agent's session with `message` as the prompt (see `wake.ts` / daemon-client.ts,
+ * which call `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.
+ * `chorus:mentioned:<uuid>`); it is used for the run id / logging. `attribution`
+ * (when present) lets the daemon client report turn-advance / execution-state /
+ * interrupt for the wake and anchor the session on the business key. 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 type ChorusWakeFn = (
+  message: string,
+  contextKey: string,
+  attribution?: WakeAttribution,
+) => void;
 
 export interface ChorusEventRouterOptions {
   mcpClient: ChorusMcpClient;
   wake: ChorusWakeFn;
+  /**
+   * Optional lineage resolver (daemon parity). When present, the router resolves each
+   * notification's `{ rootIdeaUuid, directIdeaUuid }` via the root-idea REST endpoint
+   * before waking, so the daemon client can anchor the session on the direct idea and
+   * report the root idea in its execution snapshot. When absent (a host with no daemon
+   * reporting), wakes carry only the entity fields the notification already provides.
+   */
+  lineage?: LineageResolver;
   logger: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void };
 }
 
@@ -39,11 +68,13 @@ interface NotificationDetail {
 export class ChorusEventRouter {
   private readonly mcpClient: ChorusMcpClient;
   private readonly wake: ChorusWakeFn;
+  private readonly lineage?: LineageResolver;
   private readonly logger: ChorusEventRouterOptions["logger"];
 
   constructor(opts: ChorusEventRouterOptions) {
     this.mcpClient = opts.mcpClient;
     this.wake = opts.wake;
+    this.lineage = opts.lineage;
     this.logger = opts.logger;
   }
 
@@ -52,6 +83,16 @@ export class ChorusEventRouter {
    * Never throws — all errors are caught and logged internally.
    */
   dispatch(event: SseNotificationEvent): void {
+    // The bidirectional daemon events `connection_registered` and `control` are
+    // forked upstream by the SSE listener (onConnectionId / onControl) and never
+    // reach the wake path. If one ever does arrive here (defense-in-depth), drop
+    // it SILENTLY — it is a known, handled-elsewhere event, NOT an unhandled one,
+    // so logging it as "ignored" would be misleading noise (and the spec requires
+    // connection_registered never be logged as ignored).
+    if (event.type === "connection_registered" || event.type === "control") {
+      return;
+    }
+
     // Only handle new_notification events (ignore count_update, etc.)
     if (event.type !== "new_notification") {
       this.logger.info(`SSE event type "${event.type}" ignored`);
@@ -103,35 +144,55 @@ export class ChorusEventRouter {
       return;
     }
 
+    // Resolve the wake attribution ONCE per notification (daemon parity). The lineage
+    // resolver returns { rootIdeaUuid, directIdeaUuid } via the root-idea REST endpoint;
+    // both null when there's no idea ancestor or no resolver is wired. The entity
+    // fields always come straight off the notification. This threads through to the
+    // daemon client so it reports/anchors against the right session + resource.
+    let attribution: WakeAttribution = {
+      entityType: notification.entityType,
+      entityUuid: notification.entityUuid,
+    };
+    if (this.lineage) {
+      try {
+        const { rootIdeaUuid, directIdeaUuid } = await this.lineage.resolve(notification);
+        attribution = { ...attribution, rootIdeaUuid, directIdeaUuid };
+      } catch (err) {
+        // A lineage failure must not lose the wake — fall back to the entity-only
+        // attribution (the daemon client then anchors on the entity uuid). Logged.
+        this.logger.warn(`Lineage resolve failed for ${notification.entityType}:${notification.entityUuid}: ${err}`);
+      }
+    }
+
     // Route based on action (which corresponds to notificationType)
     try {
       switch (notification.action) {
         case "task_assigned":
-          this.handleTaskAssigned(notification);
+          this.handleTaskAssigned(notification, attribution);
           break;
         case "mentioned":
-          this.handleMentioned(notification);
+          this.handleMentioned(notification, attribution);
           break;
         case "elaboration_requested":
-          this.handleElaborationRequested(notification);
+          this.handleElaborationRequested(notification, attribution);
           break;
         case "elaboration_answered":
-          this.handleElaborationAnswered(notification);
+          this.handleElaborationAnswered(notification, attribution);
           break;
         case "proposal_rejected":
-          this.handleProposalRejected(notification);
+          this.handleProposalRejected(notification, attribution);
           break;
         case "proposal_approved":
-          this.handleProposalApproved(notification);
+          this.handleProposalApproved(notification, attribution);
           break;
         case "idea_claimed":
-          this.handleIdeaClaimed(notification);
+          this.handleIdeaClaimed(notification, attribution);
           break;
         case "task_verified":
-          this.handleTaskVerified(notification);
+          this.handleTaskVerified(notification, attribution);
           break;
         case "task_reopened":
-          this.handleTaskReopened(notification);
+          this.handleTaskReopened(notification, attribution);
           break;
         default:
           this.logger.info(`Unhandled notification action: "${notification.action}"`);
@@ -153,34 +214,37 @@ export class ChorusEventRouter {
     );
   }
 
-  private handleTaskAssigned(n: NotificationDetail): void {
+  private handleTaskAssigned(n: NotificationDetail, attr: WakeAttribution): void {
     const mentionGuidance = this.buildMentionGuidance(n, "task");
 
     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)
+      this.contextKeyFor("task_assigned", n.entityUuid),
+      attr
     );
   }
 
-  private handleMentioned(n: NotificationDetail): void {
+  private handleMentioned(n: NotificationDetail, attr: WakeAttribution): void {
     const mentionGuidance = this.buildMentionGuidance(n, n.entityType);
 
     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,
-      this.contextKeyFor("mentioned", n.entityUuid)
+      this.contextKeyFor("mentioned", n.entityUuid),
+      attr
     );
   }
 
-  private handleElaborationRequested(n: NotificationDetail): void {
+  private handleElaborationRequested(n: NotificationDetail, attr: WakeAttribution): void {
     this.wake(
       `[Chorus] Elaboration requested for idea '${n.entityTitle}' (ideaUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). Use chorus_get_elaboration to review questions.`,
-      this.contextKeyFor("elaboration_requested", n.entityUuid)
+      this.contextKeyFor("elaboration_requested", n.entityUuid),
+      attr
     );
   }
 
-  private handleProposalRejected(n: NotificationDetail): void {
+  private handleProposalRejected(n: NotificationDetail, attr: WakeAttribution): void {
     const mentionGuidance = this.buildMentionGuidance(n, "proposal");
 
     this.wake(
@@ -188,11 +252,12 @@ export class ChorusEventRouter {
       `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,
-      this.contextKeyFor("proposal_rejected", n.entityUuid)
+      this.contextKeyFor("proposal_rejected", n.entityUuid),
+      attr
     );
   }
 
-  private handleProposalApproved(n: NotificationDetail): void {
+  private handleProposalApproved(n: NotificationDetail, attr: WakeAttribution): void {
     const mentionGuidance = this.buildMentionGuidance(n, "proposal");
 
     const reviewInfo = n.message.includes("Note: ") ? ` Review note: "${n.message.split("Note: ").pop()}"` : "";
@@ -200,40 +265,44 @@ export class ChorusEventRouter {
       `[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,
-      this.contextKeyFor("proposal_approved", n.entityUuid)
+      this.contextKeyFor("proposal_approved", n.entityUuid),
+      attr
     );
   }
 
-  private handleIdeaClaimed(n: NotificationDetail): void {
+  private handleIdeaClaimed(n: NotificationDetail, attr: WakeAttribution): void {
     const mentionGuidance = this.buildMentionGuidance(n, "idea");
 
     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,
-      this.contextKeyFor("idea_claimed", n.entityUuid)
+      this.contextKeyFor("idea_claimed", n.entityUuid),
+      attr
     );
   }
 
-  private handleTaskVerified(n: NotificationDetail): void {
+  private handleTaskVerified(n: NotificationDetail, attr: WakeAttribution): void {
     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.`,
-      this.contextKeyFor("task_verified", n.entityUuid)
+      this.contextKeyFor("task_verified", n.entityUuid),
+      attr
     );
   }
 
-  private handleTaskReopened(n: NotificationDetail): void {
+  private handleTaskReopened(n: NotificationDetail, attr: WakeAttribution): void {
     const mentionGuidance = this.buildMentionGuidance(n, "task");
 
     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}`,
-      this.contextKeyFor("task_reopened", n.entityUuid)
+      this.contextKeyFor("task_reopened", n.entityUuid),
+      attr
     );
   }
 
-  private handleElaborationAnswered(n: NotificationDetail): void {
+  private handleElaborationAnswered(n: NotificationDetail, attr: WakeAttribution): void {
     const mentionGuidance = this.buildMentionGuidance(n, "idea");
 
     this.wake(
@@ -243,7 +312,8 @@ export class ChorusEventRouter {
       `- 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,
-      this.contextKeyFor("elaboration_answered", n.entityUuid)
+      this.contextKeyFor("elaboration_answered", n.entityUuid),
+      attr
     );
   }
 }