@vellumai/assistant 0.8.2 → 0.8.3

package/src/memory/v2/injection.ts

@@ -38,6 +38,10 @@ import {
   spreadActivation,
 } from "./activation.js";
 import { hydrate, save } from "./activation-store.js";
+import {
+  getCliCommandCapability,
+  isCliCommandSlug,
+} from "./cli-command-store.js";
 import { getEdgeIndex } from "./edge-index.js";
 import { readPage, renderPageContent } from "./page-store.js";
 import { runRouter } from "./router.js";
@@ -355,20 +359,22 @@ async function finalizeInjection(args: {
   // on that user message and the agent keeps seeing it across subsequent turns
   // until compaction evicts the turn.
   //
-  // Skill slugs whose in-process cache entry is missing (e.g. startup race
-  // between the skill seed and the first turn, or stale Qdrant index pointing
-  // at an uninstalled skill) are excluded from `everInjected` so future
-  // per-turn runs re-attempt attachment once the cache is populated. Without
-  // this, the slug would be marked injected even though `renderInjectionBlock`
-  // silently dropped it.
-  const missingSkillSlugs = new Set(
+  // Synthetic slugs (skills, CLI commands) whose in-process cache entry is
+  // missing (e.g. startup race between the seed and the first turn, or stale
+  // Qdrant index pointing at an uninstalled skill / removed CLI command) are
+  // excluded from `everInjected` so future per-turn runs re-attempt attachment
+  // once the cache is populated. Without this, the slug would be marked
+  // injected even though `renderInjectionBlock` silently dropped it.
+  const missingSyntheticSlugs = new Set(
     slugsToRender.filter(
-      (slug) => isSkillSlug(slug) && !getSkillCapability(slug),
+      (slug) =>
+        (isSkillSlug(slug) && !getSkillCapability(slug)) ||
+        (isCliCommandSlug(slug) && !getCliCommandCapability(slug)),
     ),
   );
   const everInjectedSet = new Set(priorEverInjected.map((entry) => entry.slug));
   const newlyInjected = slugsToRender.filter(
-    (slug) => !everInjectedSet.has(slug) && !missingSkillSlugs.has(slug),
+    (slug) => !everInjectedSet.has(slug) && !missingSyntheticSlugs.has(slug),
   );
   const nextEverInjected: EverInjectedEntry[] = [
     ...priorEverInjected,
@@ -728,18 +734,18 @@ const INJECTION_HEADER =
  * distinguish "file vanished" (stale index) from "file is malformed"
  * (data-corruption / programmer error).
  *
- * Skill slugs whose entry the cache no longer knows (e.g. uninstalled
- * mid-run) are silently dropped, mirroring the missing-pages behavior but
- * without entering `missingSlugs` — the skill catalog is the source of
- * truth for skill availability, not on-disk concept pages, so a missing
- * skill is an expected catalog-level outcome rather than a stale-index
- * bug.
+ * Skill and CLI-command slugs whose entry the in-process cache no longer
+ * knows (e.g. uninstalled mid-run, or a CLI command removed between seeds)
+ * are silently dropped, mirroring the missing-pages behavior but without
+ * entering `missingSlugs` — the synthetic catalogs are the source of truth
+ * for those entries, not on-disk concept pages.
  *
  * Each concept-page section is rendered as a path header followed by either
  * the page's `summary` (when present in frontmatter) or the full page (the
- * fallback for pages predating the summary field). Skills sit at the end
- * under `### Skills You Can Use`, unchanged. The leading `**CRITICAL:**`
- * line tells the agent how to read the block.
+ * fallback for pages predating the summary field). Skills sit after the
+ * concept sections under `### Skills You Can Use`, and CLI subcommands sit
+ * after the skills under `### CLI Commands You Can Use`. The leading
+ * `**CRITICAL:**` line tells the agent how to read the block.
  *
  *   **CRITICAL:** These are page summaries. Read the page file if it looks relevant.
  *
@@ -758,13 +764,24 @@ const INJECTION_HEADER =
  *   ### Skills You Can Use
  *   - <skill-1 content>
  *   - <skill-2 content>
+ *
+ *   ### CLI Commands You Can Use
+ *   Run `assistant <command> --help` for full usage.
+ *   - `assistant <name-1>`: <description-1>
+ *   - `assistant <name-2>`: <description-2>
  */
 async function renderInjectionBlock(
   workspaceDir: string,
   slugs: string[],
 ): Promise<RenderInjectionBlockResult> {
-  const conceptSlugs = slugs.filter((s) => !isSkillSlug(s));
-  const skillSlugs = slugs.filter((s) => isSkillSlug(s));
+  const conceptSlugs: string[] = [];
+  const skillSlugs: string[] = [];
+  const cliCommandSlugs: string[] = [];
+  for (const slug of slugs) {
+    if (isSkillSlug(slug)) skillSlugs.push(slug);
+    else if (isCliCommandSlug(slug)) cliCommandSlugs.push(slug);
+    else conceptSlugs.push(slug);
+  }
 
   const settled = await Promise.allSettled(
     conceptSlugs.map((slug) => readPage(workspaceDir, slug)),
@@ -815,6 +832,18 @@ async function renderInjectionBlock(
     sections.push(`### Skills You Can Use\n${skillLines.join("\n")}`);
   }
 
+  const cliCommandLines: string[] = [];
+  for (const slug of cliCommandSlugs) {
+    const entry = getCliCommandCapability(slug);
+    if (!entry) continue;
+    cliCommandLines.push(`- \`assistant ${entry.id}\`: ${entry.description}`);
+  }
+  if (cliCommandLines.length > 0) {
+    sections.push(
+      `### CLI Commands You Can Use\nRun \`assistant <command> --help\` for full usage.\n${cliCommandLines.join("\n")}`,
+    );
+  }
+
   if (sections.length === 0) {
     return { block: null, missingSlugs, corruptSlugs };
   }

package/src/memory/v2/page-index.ts

@@ -80,11 +80,12 @@ let cache: CachedIndex | null = null;
 /**
  * Return a `PageIndex` for `workspaceDir`. Cached module-locally; the cache
  * is invalidated by `invalidatePageIndex` (called by daemon-side hooks when
- * concept pages or skill entries change).
+ * concept pages, skill entries, or CLI-command entries change).
  *
  * Cold builds list every concept page in parallel, drop pages whose read
- * rejects, append seeded skill entries from `listSkillEntries()`, sort by
- * slug for deterministic IDs, then resolve outgoing edges to numeric IDs.
+ * rejects, append seeded skill entries from `listSkillEntries()` and CLI
+ * command entries from `listCliCommandEntries()`, sort by slug for
+ * deterministic IDs, then resolve outgoing edges to numeric IDs.
  */
 export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
   if (cache && cache.workspaceDir === workspaceDir) {
@@ -107,20 +108,29 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
     outgoingSlugs: string[];
   }
 
-  const { listSkillEntries, SKILL_SLUG_PREFIX } =
-    await import("./skill-store.js");
-
-  // Build the skill-slug set first so we can drop colliding concept pages.
-  // Collision policy: **skill entries win**. Skill rows are seeded from the
-  // curated catalog and the router needs them to be reachable under their
-  // canonical slugs; a hand-authored page sitting under `skills/<id>` is
-  // either a stale leftover from a prior write or a user mistake. `bySlug`
-  // is last-writer-wins, so without explicit dedupe one side would silently
-  // shadow the other depending on iteration order.
+  const [
+    { listSkillEntries, SKILL_SLUG_PREFIX },
+    { listCliCommandEntries, CLI_COMMAND_SLUG_PREFIX },
+  ] = await Promise.all([
+    import("./skill-store.js"),
+    import("./cli-command-store.js"),
+  ]);
+
+  // Build the synthetic-slug sets first so we can drop colliding concept
+  // pages. Collision policy: **synthetic entries win**. Skill and CLI rows
+  // are seeded from authoritative in-process catalogs; a hand-authored page
+  // sitting under `skills/<id>` or `cli-commands/<name>` is either a stale
+  // leftover from a prior write or a user mistake. `bySlug` is last-writer-
+  // wins, so without explicit dedupe one side would silently shadow the
+  // other depending on iteration order.
   const skillEntries = listSkillEntries();
   const skillSlugs = new Set(
     skillEntries.map((entry) => `${SKILL_SLUG_PREFIX}${entry.id}`),
   );
+  const cliCommandEntries = listCliCommandEntries();
+  const cliCommandSlugs = new Set(
+    cliCommandEntries.map((entry) => `${CLI_COMMAND_SLUG_PREFIX}${entry.id}`),
+  );
 
   const drafts: DraftEntry[] = [];
   for (let i = 0; i < settled.length; i++) {
@@ -142,6 +152,13 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       );
       continue;
     }
+    if (cliCommandSlugs.has(slug)) {
+      log.warn(
+        { slug },
+        "Dropping concept page from index — slug collides with a seeded CLI-command entry; CLI command wins",
+      );
+      continue;
+    }
     const summarySource = page.frontmatter.summary?.trim() || page.body.trim();
     drafts.push({
       slug,
@@ -158,6 +175,14 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
     });
   }
 
+  for (const entry of cliCommandEntries) {
+    drafts.push({
+      slug: `${CLI_COMMAND_SLUG_PREFIX}${entry.id}`,
+      summary: normalizeSummary(entry.description),
+      outgoingSlugs: [],
+    });
+  }
+
   drafts.sort((a, b) => (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0));
 
   // Assign 1-based dense IDs in sort order so entries[i].id === i + 1.

package/src/memory/v2/static-context.ts

@@ -35,9 +35,9 @@ const MEMORY_V2_STATIC_BLOCKS: readonly MemoryV2StaticBlock[] = [
 ];
 
 /**
- * Build the v2 static memory block, gated on `config.memory.v2.enabled`.
- * Empty/missing files are skipped; returns `null` when the gate is off or
- * every file is empty.
+ * Build the v2 static memory block, gated on `config.memory.enabled` and
+ * `config.memory.v2.enabled`. Empty/missing files are skipped; returns `null`
+ * when either gate is off or every file is empty.
  */
 export function readMemoryV2StaticContent(): string | null {
   let config;
@@ -46,7 +46,7 @@ export function readMemoryV2StaticContent(): string | null {
   } catch {
     return null;
   }
-  if (!config.memory.v2.enabled) {
+  if (!config.memory.enabled || !config.memory.v2.enabled) {
     return null;
   }
 

package/src/memory/v2/types.ts

@@ -115,3 +115,26 @@ export interface SkillEntry {
   id: string;
   content: string;
 }
+
+// ---------------------------------------------------------------------------
+// CLI-command entries (synthetic concept-collection rows, not on-disk pages)
+// ---------------------------------------------------------------------------
+
+/**
+ * Per-CLI-subcommand capability snapshot held in-process and embedded into the
+ * unified `memory_v2_concept_pages` Qdrant collection under the slug
+ * `cli-commands/<name>`. `content` is the full `helpInformation()` output for
+ * the top-level subcommand — the embedding target, intentionally uncapped so
+ * activation hints in flag descriptions and examples carry semantic weight.
+ * `description` is the one-line Commander description, rendered terse in
+ * `### CLI Commands You Can Use` so the injection block stays compact even
+ * for verbose `--help` outputs.
+ *
+ * Plain interface (no Zod) — same in-process-only justification as
+ * `SkillEntry`.
+ */
+export interface CliCommandEntry {
+  id: string;
+  description: string;
+  content: string;
+}

package/src/messaging/providers/a2a/__tests__/deliver.test.ts

@@ -0,0 +1,274 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ChannelReplyPayload } from "@vellumai/gateway-client";
+
+import type { A2ATask, Artifact } from "../../../../a2a/protocol-types.js";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+let completedTask: A2ATask | null = null;
+let completeWithArtifactsCalls: Array<{
+  taskId: string;
+  artifacts: Artifact[];
+}> = [];
+let pushUrlByTaskId: Record<string, string | null> = {};
+let completeError: Error | null = null;
+
+const fetchCalls: Array<{
+  url: string;
+  init: RequestInit;
+}> = [];
+let fetchResponses: Array<{ ok: boolean; status: number; body: string }> = [];
+let fetchCallIndex = 0;
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+const defaultTask: A2ATask = {
+  id: "task-123",
+  status: { state: "completed", timestamp: new Date().toISOString() },
+  artifacts: [
+    {
+      artifact_id: "art-1",
+      parts: [{ kind: "text", text: "Hello from assistant" }],
+    },
+  ],
+};
+
+mock.module("../../../../a2a/task-store.js", () => ({
+  completeWithArtifacts: (taskId: string, artifacts: Artifact[]): A2ATask => {
+    completeWithArtifactsCalls.push({ taskId, artifacts });
+    if (completeError) throw completeError;
+    return completedTask ?? defaultTask;
+  },
+  getPushUrl: (taskId: string): string | null => {
+    return pushUrlByTaskId[taskId] ?? null;
+  },
+}));
+
+mock.module("../../../../util/logger.js", () => ({
+  getLogger: () => ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+// Intercept global fetch for push notification testing
+const originalFetch = globalThis.fetch;
+
+// Import the module under test AFTER mocks are set up
+const { deliverA2AReply } = await import("../deliver.js");
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  completedTask = null;
+  completeWithArtifactsCalls = [];
+  pushUrlByTaskId = {};
+  completeError = null;
+  fetchCalls.length = 0;
+  fetchResponses = [];
+  fetchCallIndex = 0;
+
+  globalThis.fetch = (async (
+    input: string | URL | Request,
+    init?: RequestInit,
+  ) => {
+    const url = typeof input === "string" ? input : input.toString();
+    fetchCalls.push({ url, init: init ?? {} });
+    const responseSpec = fetchResponses[fetchCallIndex++] ?? {
+      ok: true,
+      status: 200,
+      body: "{}",
+    };
+    return new Response(responseSpec.body, {
+      status: responseSpec.status,
+      statusText: responseSpec.ok ? "OK" : "Error",
+    });
+  }) as typeof fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("deliverA2AReply", () => {
+  const baseCallbackUrl = "https://example.com/deliver/a2a?taskId=task-123";
+
+  test("completes task with text artifact", async () => {
+    const payload: ChannelReplyPayload = {
+      chatId: "chat-1",
+      text: "Hello from the assistant",
+    };
+
+    const result = await deliverA2AReply(baseCallbackUrl, payload);
+
+    expect(result.ok).toBe(true);
+    expect(completeWithArtifactsCalls).toHaveLength(1);
+    expect(completeWithArtifactsCalls[0].taskId).toBe("task-123");
+    expect(completeWithArtifactsCalls[0].artifacts).toHaveLength(1);
+    expect(completeWithArtifactsCalls[0].artifacts[0].parts).toEqual([
+      { kind: "text", text: "Hello from the assistant" },
+    ]);
+  });
+
+  test("completes task with file attachments", async () => {
+    const payload: ChannelReplyPayload = {
+      chatId: "chat-1",
+      text: "Here is a file",
+      attachments: [
+        {
+          id: "att-1",
+          filename: "report.pdf",
+          mimeType: "application/pdf",
+          sizeBytes: 1024,
+          kind: "file",
+          data: "data:application/pdf;base64,abc123",
+        },
+      ],
+    };
+
+    const result = await deliverA2AReply(baseCallbackUrl, payload);
+
+    expect(result.ok).toBe(true);
+    expect(completeWithArtifactsCalls).toHaveLength(1);
+    const parts = completeWithArtifactsCalls[0].artifacts[0].parts;
+    expect(parts).toHaveLength(2);
+    expect(parts[0]).toEqual({
+      kind: "text",
+      text: "Here is a file",
+    });
+    expect(parts[1]).toEqual({
+      kind: "file",
+      filename: "report.pdf",
+      media_type: "application/pdf",
+      url: "data:application/pdf;base64,abc123",
+    });
+  });
+
+  test("returns ok: false when taskId is missing from URL", async () => {
+    const result = await deliverA2AReply("https://example.com/deliver/a2a", {
+      chatId: "chat-1",
+      text: "Hello",
+    });
+
+    expect(result.ok).toBe(false);
+    expect(completeWithArtifactsCalls).toHaveLength(0);
+  });
+
+  test("returns ok: true when payload has no content", async () => {
+    const result = await deliverA2AReply(baseCallbackUrl, {
+      chatId: "chat-1",
+    });
+
+    expect(result.ok).toBe(true);
+    expect(completeWithArtifactsCalls).toHaveLength(0);
+  });
+
+  test("returns ok: false when task completion throws", async () => {
+    completeError = new Error("A2A task not found: task-123");
+
+    const result = await deliverA2AReply(baseCallbackUrl, {
+      chatId: "chat-1",
+      text: "Hello",
+    });
+
+    expect(result.ok).toBe(false);
+  });
+
+  test("returns ok: false when task is already terminal", async () => {
+    completeError = new Error(
+      'Cannot transition task task-123 from terminal state "completed" to "completed"',
+    );
+
+    const result = await deliverA2AReply(baseCallbackUrl, {
+      chatId: "chat-1",
+      text: "Hello",
+    });
+
+    expect(result.ok).toBe(false);
+  });
+
+  describe("push notifications", () => {
+    test("POSTs completed task to push URL", async () => {
+      pushUrlByTaskId["task-123"] = "https://requester.example.com/push";
+      fetchResponses = [{ ok: true, status: 200, body: "{}" }];
+
+      const result = await deliverA2AReply(baseCallbackUrl, {
+        chatId: "chat-1",
+        text: "Done",
+      });
+
+      expect(result.ok).toBe(true);
+
+      // Wait for the fire-and-forget push to complete
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(fetchCalls).toHaveLength(1);
+      expect(fetchCalls[0].url).toBe("https://requester.example.com/push");
+      expect(fetchCalls[0].init.method).toBe("POST");
+
+      const headers = fetchCalls[0].init.headers as Record<string, string>;
+      expect(headers["Content-Type"]).toBe("application/a2a+json");
+      expect(headers["A2A-Version"]).toBe("1.0");
+    });
+
+    test("does not push when no push URL configured", async () => {
+      const result = await deliverA2AReply(baseCallbackUrl, {
+        chatId: "chat-1",
+        text: "Done",
+      });
+
+      expect(result.ok).toBe(true);
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(fetchCalls).toHaveLength(0);
+    });
+
+    test("push failure does not affect delivery result", async () => {
+      pushUrlByTaskId["task-123"] = "https://requester.example.com/push";
+      // All retries fail with 500
+      fetchResponses = Array(4).fill({
+        ok: false,
+        status: 500,
+        body: "Internal Server Error",
+      });
+
+      const result = await deliverA2AReply(baseCallbackUrl, {
+        chatId: "chat-1",
+        text: "Done",
+      });
+
+      // Delivery still succeeds even though push will fail
+      expect(result.ok).toBe(true);
+    });
+
+    test("stops retrying on non-retryable client error", async () => {
+      pushUrlByTaskId["task-123"] = "https://requester.example.com/push";
+      fetchResponses = [{ ok: false, status: 404, body: "Not Found" }];
+
+      await deliverA2AReply(baseCallbackUrl, {
+        chatId: "chat-1",
+        text: "Done",
+      });
+
+      // Wait for the fire-and-forget push to settle
+      await new Promise((r) => setTimeout(r, 50));
+
+      // Should only attempt once on a 4xx (non-429) error
+      expect(fetchCalls).toHaveLength(1);
+    });
+  });
+});

package/src/messaging/providers/a2a/deliver.ts

@@ -0,0 +1,156 @@
+/**
+ * A2A direct delivery adapter.
+ *
+ * Completes an A2A task with response artifacts and optionally POSTs the
+ * completed task to the requester's push notification URL.
+ */
+
+import type {
+  ChannelDeliveryResult,
+  ChannelReplyPayload,
+} from "@vellumai/gateway-client";
+
+import {
+  A2A_CONTENT_TYPE,
+  A2A_VERSION,
+  A2A_VERSION_HEADER,
+} from "../../../a2a/protocol-constants.js";
+import type { Part } from "../../../a2a/protocol-types.js";
+import * as taskStore from "../../../a2a/task-store.js";
+import { getLogger } from "../../../util/logger.js";
+import {
+  computeRetryDelay,
+  isRetryableStatus,
+  sleep,
+} from "../../../util/retry.js";
+
+const log = getLogger("a2a-deliver");
+
+const MAX_RETRIES = 3;
+const PUSH_TIMEOUT_MS = 15_000;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Extract the `taskId` query parameter from a callback URL. */
+function parseTaskId(callbackUrl: string): string | null {
+  try {
+    return new URL(callbackUrl).searchParams.get("taskId");
+  } catch {
+    return null;
+  }
+}
+
+/** Build A2A parts from a channel reply payload. */
+function buildParts(payload: ChannelReplyPayload): Part[] {
+  const parts: Part[] = [];
+
+  if (payload.text) {
+    parts.push({ kind: "text", text: payload.text });
+  }
+
+  if (payload.attachments) {
+    for (const att of payload.attachments) {
+      parts.push({
+        kind: "file",
+        filename: att.filename,
+        media_type: att.mimeType,
+        url: att.data,
+      });
+    }
+  }
+
+  return parts;
+}
+
+/** POST the completed task to the requester's push URL with retry. */
+async function pushNotification(
+  pushUrl: string,
+  taskJson: unknown,
+): Promise<void> {
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    if (attempt > 0) {
+      await sleep(computeRetryDelay(attempt - 1));
+    }
+
+    try {
+      const response = await fetch(pushUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": A2A_CONTENT_TYPE,
+          [A2A_VERSION_HEADER]: A2A_VERSION,
+        },
+        body: JSON.stringify(taskJson),
+        signal: AbortSignal.timeout(PUSH_TIMEOUT_MS),
+      });
+
+      if (response.ok) return;
+
+      const body = await response.text().catch(() => "");
+      lastError = new Error(
+        `Push notification failed with status ${response.status}: ${body}`,
+      );
+
+      if (!isRetryableStatus(response.status)) {
+        break;
+      }
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+    }
+  }
+
+  // Push failure is logged but doesn't propagate
+  log.warn(
+    { pushUrl, error: lastError?.message },
+    "A2A push notification failed after retries",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/** Deliver an assistant reply as an A2A task completion. */
+export async function deliverA2AReply(
+  callbackUrl: string,
+  payload: ChannelReplyPayload,
+): Promise<ChannelDeliveryResult> {
+  const taskId = parseTaskId(callbackUrl);
+  if (!taskId) {
+    return { ok: false };
+  }
+
+  const parts = buildParts(payload);
+  if (parts.length === 0) {
+    log.debug({ taskId }, "No content to deliver; skipping A2A completion");
+    return { ok: true };
+  }
+
+  let completedTask;
+  try {
+    completedTask = taskStore.completeWithArtifacts(taskId, [
+      { artifact_id: crypto.randomUUID(), parts },
+    ]);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ taskId, error: message }, "Failed to complete A2A task");
+    return { ok: false };
+  }
+
+  // Push notification — fire-and-forget
+  const pushUrl = taskStore.getPushUrl(taskId);
+  if (pushUrl) {
+    pushNotification(pushUrl, completedTask).catch((err) => {
+      log.error(
+        { taskId, pushUrl, error: String(err) },
+        "Unexpected push notification error",
+      );
+    });
+  }
+
+  log.info({ taskId }, "A2A reply delivered");
+  return { ok: true };
+}