@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/shell-observability.test.ts

@@ -0,0 +1,249 @@
+/**
+ * Verifies the structured logs added to the `bash` tool by the
+ * subprocess-orphan observability change:
+ *
+ *   1. Every invocation emits a `"Shell command exited"` info log with
+ *      `command`, `mode`, `durationMs`, `exitCode`, `signal`, `timedOut`.
+ *   2. Every group-SIGKILL (timeout / abort) emits a `"Shell process
+ *      group SIGKILL'd"` warn log with `reason` so post-mortems can map
+ *      orphans back to the call site that orphaned them.
+ *
+ * These logs are the only ground-truth signal that lets the daemon
+ * trace zombie accumulation back to a specific shell command — the
+ * tests pin them in place so a future refactor can't quietly drop them.
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { WakeOptions } from "../runtime/agent-wake.js";
+import type { BackgroundTool } from "../tools/background-tool-registry.js";
+
+// ── Mock modules ────────────────────────────────────────────────────────────
+
+interface LogCall {
+  level: "info" | "warn" | "debug" | "error";
+  fields: Record<string, unknown>;
+  msg: string;
+}
+const logCalls: LogCall[] = [];
+
+function recordLog(level: LogCall["level"]) {
+  return (fields: Record<string, unknown> | string, msg?: string) => {
+    if (typeof fields === "string") {
+      logCalls.push({ level, fields: {}, msg: fields });
+    } else {
+      logCalls.push({ level, fields, msg: msg ?? "" });
+    }
+  };
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: recordLog("info"),
+    warn: recordLog("warn"),
+    debug: recordLog("debug"),
+    error: recordLog("error"),
+  }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    // 1s timeout so the timeout-path test doesn't take forever.
+    timeouts: { shellDefaultTimeoutSec: 120, shellMaxTimeoutSec: 600 },
+    sandbox: {
+      enabled: false,
+      backend: "native",
+      docker: {
+        image: "vellum-sandbox:latest",
+        shell: "bash",
+        cpus: 1,
+        memoryMb: 512,
+        pidsLimit: 256,
+        network: "none",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+mock.module("../tools/network/script-proxy/index.js", () => ({
+  getOrStartSession: mock(() =>
+    Promise.resolve({ session: { id: "mock-session" } }),
+  ),
+  getSessionEnv: mock(() => ({})),
+  createSession: () => {},
+  startSession: () => {},
+  stopSession: () => {},
+  getActiveSession: () => null,
+  getSessionsForConversation: () => [],
+  stopAllSessions: () => {},
+  ensureLocalCA: () => {},
+  ensureCombinedCABundle: () => {},
+  issueLeafCert: () => {},
+  getCAPath: () => "",
+  getCombinedCAPath: () => "",
+}));
+
+const mockWakeAgentForOpportunity = mock(
+  (
+    _opts: WakeOptions,
+  ): Promise<{ invoked: boolean; producedToolCalls: boolean }> =>
+    Promise.resolve({ invoked: true, producedToolCalls: false }),
+);
+
+mock.module("../runtime/agent-wake.js", () => ({
+  wakeAgentForOpportunity: mockWakeAgentForOpportunity,
+}));
+
+const registeredTools: BackgroundTool[] = [];
+
+mock.module("../tools/background-tool-registry.js", () => ({
+  registerBackgroundTool: (tool: BackgroundTool) => {
+    registeredTools.push(tool);
+  },
+  removeBackgroundTool: (id: string) => {
+    const idx = registeredTools.findIndex((t) => t.id === id);
+    if (idx !== -1) registeredTools.splice(idx, 1);
+  },
+  generateBackgroundToolId: () => "bg-obs-test",
+  isBackgroundToolLimitReached: () => false,
+  MAX_BACKGROUND_TOOLS: 20,
+}));
+
+// ── Imports (after mocks) ───────────────────────────────────────────────────
+
+// `shellTool` is imported dynamically inside `beforeEach` so the logger
+// mock above lands before shell.ts evaluates and captures its `getLogger`
+// reference — static imports hoist past `mock.module()` and the test
+// would see the real pino logger instead of the in-memory `logCalls`
+// array. The shape type below mirrors the satisfies-narrowed export so
+// `shellTool.execute(...)` keeps its required-execute typing without a
+// `!` bang.
+let shellTool: (typeof import("../tools/terminal/shell.js"))["shellTool"];
+
+const baseContext = {
+  workingDir: process.env.VELLUM_WORKSPACE_DIR ?? "/tmp",
+  conversationId: "conv-obs-test",
+  trustClass: "guardian" as const,
+  onOutput: () => {},
+};
+
+type LogPredicate = (call: LogCall) => boolean;
+
+function findLog(predicate: LogPredicate): LogCall | undefined {
+  return logCalls.find(predicate);
+}
+
+function waitForLog(
+  predicate: LogPredicate,
+  label: string,
+  timeoutMs = 5_000,
+): Promise<LogCall> {
+  return new Promise<LogCall>((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`timed out waiting for ${label}`)),
+      timeoutMs,
+    );
+    const check = () => {
+      const hit = findLog(predicate);
+      if (hit) {
+        clearTimeout(timer);
+        return resolve(hit);
+      }
+      setTimeout(check, 25);
+    };
+    check();
+  });
+}
+
+const isExit = (mode: "foreground" | "background") => (c: LogCall) =>
+  c.level === "info" &&
+  c.msg === "Shell command exited" &&
+  c.fields.mode === mode;
+
+const isKill = (reason: string) => (c: LogCall) =>
+  c.level === "warn" &&
+  c.msg.startsWith("Shell process group SIGKILL") &&
+  c.fields.reason === reason;
+
+describe("shell observability logs", () => {
+  beforeEach(async () => {
+    logCalls.length = 0;
+    registeredTools.length = 0;
+    const mod = await import("../tools/terminal/shell.js");
+    shellTool = mod.shellTool;
+  });
+
+  afterEach(() => {
+    logCalls.length = 0;
+    registeredTools.length = 0;
+  });
+
+  test("foreground exit emits structured 'Shell command exited' info log", async () => {
+    const result = await shellTool.execute(
+      { command: "echo obs-foreground", activity: "test" },
+      baseContext,
+    );
+    expect(result.isError).toBe(false);
+
+    const exit = findLog(isExit("foreground"));
+    expect(exit).toBeDefined();
+    expect(exit!.fields.exitCode).toBe(0);
+    expect(exit!.fields.signal).toBeNull();
+    expect(exit!.fields.timedOut).toBe(false);
+    expect(exit!.fields.conversationId).toBe("conv-obs-test");
+    expect(exit!.fields.command).toBe("echo obs-foreground");
+    expect(typeof exit!.fields.durationMs).toBe("number");
+  });
+
+  test("foreground timeout emits killTree warn + exit log with timedOut=true", async () => {
+    const result = await shellTool.execute(
+      { command: "sleep 30", activity: "test", timeout_seconds: 1 },
+      baseContext,
+    );
+    expect(result.isError).toBe(true);
+
+    const kill = findLog(isKill("timeout"));
+    expect(kill).toBeDefined();
+    expect(kill!.fields.command).toBe("sleep 30");
+    expect(kill!.fields.conversationId).toBe("conv-obs-test");
+    expect(typeof kill!.fields.groupPid).toBe("number");
+
+    const exit = findLog(
+      (c) => isExit("foreground")(c) && c.fields.timedOut === true,
+    );
+    expect(exit).toBeDefined();
+  }, 10_000);
+
+  test("background mode emits an exit log with mode='background' and the bg invocationId", async () => {
+    await shellTool.execute(
+      { command: "echo bg-obs", activity: "test", background: true },
+      baseContext,
+    );
+
+    const exit = await waitForLog(
+      (c) => isExit("background")(c) && c.fields.invocationId === "bg-obs-test",
+      "background exit log",
+    );
+    expect(exit.fields.exitCode).toBe(0);
+    expect(exit.fields.timedOut).toBe(false);
+  });
+
+  test("aborted foreground command emits killTree warn with reason='abort'", async () => {
+    const controller = new AbortController();
+    const execPromise = shellTool.execute(
+      { command: "sleep 30", activity: "test" },
+      { ...baseContext, signal: controller.signal },
+    );
+
+    // Abort once the child has been spawned. A microtask is enough; we
+    // poll the log buffer up to 2 s for the warn so the test isn't
+    // sensitive to scheduler jitter.
+    setTimeout(() => controller.abort(), 50);
+
+    await execPromise;
+
+    const kill = await waitForLog(isKill("abort"), "abort kill log", 2_000);
+    expect(kill.fields.command).toBe("sleep 30");
+  });
+});

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -7,17 +7,15 @@
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  _setOverridesForTesting,
-  isAssistantFeatureFlagEnabled,
-} from "../config/assistant-feature-flags.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 beforeEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 import type { AssistantConfig } from "../config/schema.js";
 import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
@@ -28,13 +26,13 @@ import { parseFrontmatterFields } from "../skills/frontmatter.js";
 // Fixtures
 // ---------------------------------------------------------------------------
 
-/** A SKILL.md with `feature-flag: email-channel` declared in its vellum metadata. */
+/** A SKILL.md with `feature-flag: a2a-channel` declared in its vellum metadata. */
 const SKILL_MD_WITH_FLAG = `---
 name: "Email Setup"
 description: "Set up email integration"
 metadata:
   vellum:
-    feature-flag: email-channel
+    feature-flag: a2a-channel
 ---
 
 Instructions for the email setup skill.
@@ -128,16 +126,16 @@ describe("frontmatter feature-flag integration", () => {
     expect(metadataObj).toBeTruthy();
 
     const vellum = metadataObj.vellum as Record<string, unknown>;
-    expect(vellum["feature-flag"]).toBe("email-channel");
+    expect(vellum["feature-flag"]).toBe("a2a-channel");
   });
 
   test("skillFlagKey returns correct key for parsed skill", () => {
     const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG);
     expect(skill).not.toBeNull();
-    expect(skill!.featureFlag).toBe("email-channel");
+    expect(skill!.featureFlag).toBe("a2a-channel");
 
     const key = skillFlagKey(skill!);
-    expect(key).toBe("email-channel");
+    expect(key).toBe("a2a-channel");
   });
 
   test("skillFlagKey returns undefined for skill without feature-flag", () => {
@@ -150,8 +148,8 @@ describe("frontmatter feature-flag integration", () => {
   });
 
   test("resolveSkillStates includes skill with featureFlag when flag is ON", () => {
-    _setOverridesForTesting({
-      "email-channel": true,
+    setOverridesForTesting({
+      "a2a-channel": true,
     });
     const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG)!;
     const config = makeConfig();
@@ -163,7 +161,7 @@ describe("frontmatter feature-flag integration", () => {
 
   test("resolveSkillStates excludes skill with featureFlag when flag defaults to OFF", () => {
     const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG)!;
-    // "email-channel" is in the registry with defaultEnabled: false
+    // "a2a-channel" is in the registry with defaultEnabled: false
     const config = makeConfig();
 
     const resolved = resolveSkillStates([skill], config);
@@ -174,7 +172,7 @@ describe("frontmatter feature-flag integration", () => {
   test("resolveSkillStates never gates skill without featureFlag", () => {
     const skill = buildSkillSummary("plain-skill", SKILL_MD_WITHOUT_FLAG)!;
     // Even with an explicit false override for this skill ID, it should pass through
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "plain-skill": false,
     });
     const config = makeConfig();
@@ -191,17 +189,17 @@ describe("frontmatter feature-flag integration", () => {
     const metadataObj = parsed!.fields.metadata as Record<string, unknown>;
     const vellum = metadataObj.vellum as Record<string, unknown>;
     const flagId = vellum["feature-flag"];
-    expect(flagId).toBe("email-channel");
+    expect(flagId).toBe("a2a-channel");
 
     // Step 2: Build SkillSummary (as the catalog loader would)
     const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG)!;
-    expect(skill.featureFlag).toBe("email-channel");
+    expect(skill.featureFlag).toBe("a2a-channel");
 
     // Step 3: Derive the flag key
     const key = skillFlagKey(skill);
-    expect(key).toBe("email-channel");
+    expect(key).toBe("a2a-channel");
 
-    // Step 4: Check flag state — "email-channel" has defaultEnabled: false in registry
+    // Step 4: Check flag state — "a2a-channel" has defaultEnabled: false in registry
     const configDefault = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configDefault)).toBe(false);
 
@@ -210,7 +208,7 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedDefault.length).toBe(0);
 
     // Step 6: With override enabled, skill passes through
-    _setOverridesForTesting({ [key!]: true });
+    setOverridesForTesting({ [key!]: true });
     const configOn = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configOn)).toBe(true);
 
@@ -219,7 +217,7 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedOn[0].summary.id).toBe("email-setup");
 
     // Step 7: With override disabled, skill is filtered out
-    _setOverridesForTesting({ [key!]: false });
+    setOverridesForTesting({ [key!]: false });
     const configOff = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configOff)).toBe(false);
 

package/src/__tests__/skill-feature-flags.test.ts

@@ -1,24 +1,22 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  _setOverridesForTesting,
-  isAssistantFeatureFlagEnabled,
-} from "../config/assistant-feature-flags.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
 import type { SkillSummary } from "../config/skills.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 beforeEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
-const DECLARED_FLAG_ID = "email-channel";
+const DECLARED_FLAG_ID = "a2a-channel";
 const DECLARED_FLAG_KEY = DECLARED_FLAG_ID;
-const DECLARED_SKILL_ID = "email-channel";
+const DECLARED_SKILL_ID = "a2a-channel";
 const ENABLED_UNDECLARED_FLAG_KEY = "enabled-undeclared-flag";
 const ENABLED_UNDECLARED_SKILL_ID = "enabled-undeclared-skill";
 // ---------------------------------------------------------------------------
@@ -103,7 +101,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   });
 
   test("returns true when skill key is explicitly true", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
     const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
@@ -114,7 +112,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   });
 
   test("returns false when skill key is explicitly false", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
@@ -136,7 +134,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 
   test("file-based override overrides registry default", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const config = makeConfig();
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
       false,
@@ -145,14 +143,14 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
   test("falls back to registry default when no override", () => {
     const config = makeConfig();
-    // email-channel defaults to false in the registry
+    // a2a-channel defaults to false in the registry
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
       false,
     );
   });
 
   test("respects persisted overrides for undeclared keys", () => {
-    _setOverridesForTesting({ "some-undeclared-flag": false });
+    setOverridesForTesting({ "some-undeclared-flag": false });
     const config = makeConfig();
     expect(isAssistantFeatureFlagEnabled("some-undeclared-flag", config)).toBe(
       false,
@@ -166,7 +164,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
 describe("resolveSkillStates with feature flags", () => {
   test("flag OFF skill does not appear in resolved list", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: false,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
     });
@@ -188,7 +186,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("flag ON skill appears normally", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: true,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
     });
@@ -214,7 +212,7 @@ describe("resolveSkillStates with feature flags", () => {
     const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
-    // email-channel registry default is false, so it is filtered out
+    // a2a-channel registry default is false, so it is filtered out
     expect(resolved.length).toBe(0);
   });
 
@@ -230,7 +228,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("feature flag OFF takes precedence over user-enabled config entry", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig({
       skills: {
@@ -256,7 +254,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("multiple skills with mixed flags — persisted overrides respected", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: false,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
       deploy: false,
@@ -275,7 +273,7 @@ describe("resolveSkillStates with feature flags", () => {
     const resolved = resolveSkillStates(catalog, config);
     const ids = resolved.map((r) => r.summary.id);
 
-    // email-channel and deploy explicitly false; one unrelated skill explicitly true
+    // a2a-channel and deploy explicitly false; one unrelated skill explicitly true
     expect(ids).toEqual([ENABLED_UNDECLARED_SKILL_ID]);
   });
 });
@@ -286,7 +284,7 @@ describe("resolveSkillStates with feature flags", () => {
 
 describe("resolveSkillStates with frontmatter featureFlag", () => {
   test("skill with featureFlag (defaultEnabled: false) is excluded when no config override", () => {
-    // email-channel has defaultEnabled: false in the registry
+    // a2a-channel has defaultEnabled: false in the registry
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig();
 
@@ -296,7 +294,7 @@ describe("resolveSkillStates with frontmatter featureFlag", () => {
   });
 
   test("skill with featureFlag is included when override enables it", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig();
 
@@ -320,7 +318,7 @@ describe("resolveSkillStates with frontmatter featureFlag", () => {
     // This proves the implicit skillId→flag mapping is gone:
     // setting feature_flags.my-skill.enabled = false has no effect
     // when the skill itself does not declare a featureFlag.
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "my-skill": false,
     });
     const catalog = [makeSkill("my-skill")];

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -6,14 +6,14 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
 let currentConfig: Record<string, unknown> = {};
 
-const DECLARED_SKILL_ID = "email-channel";
-const DECLARED_FLAG_KEY = "email-channel";
+const DECLARED_SKILL_ID = "a2a-channel";
+const DECLARED_FLAG_KEY = "a2a-channel";
 
 const noopLogger = new Proxy({} as Record<string, unknown>, {
   get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
@@ -89,22 +89,22 @@ describe("skill_load feature flag enforcement", () => {
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
     currentConfig = {};
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   test("returns deterministic error for flag OFF skill", async () => {
     writeSkill(
       DECLARED_SKILL_ID,
-      "Email Channel",
-      "Toggle email channel behavior",
+      "A2A Channel",
+      "Toggle A2A channel behavior",
       "Use the feature.",
     );
 
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
@@ -116,24 +116,24 @@ describe("skill_load feature flag enforcement", () => {
   test("loads skill normally when flag is ON", async () => {
     writeSkill(
       DECLARED_SKILL_ID,
-      "Email Channel",
-      "Toggle email channel behavior",
+      "A2A Channel",
+      "Toggle A2A channel behavior",
       "Use the feature.",
     );
 
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("Skill: Email Channel");
+    expect(result.content).toContain("Skill: A2A Channel");
   });
 
   test("returns error when flag key is absent (registry defaults to disabled)", async () => {
     writeSkill(
       DECLARED_SKILL_ID,
-      "Email Channel",
-      "Toggle email channel behavior",
+      "A2A Channel",
+      "Toggle A2A channel behavior",
       "Use the feature.",
     );
 
@@ -141,7 +141,7 @@ describe("skill_load feature flag enforcement", () => {
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
-    // email-channel is declared in the registry with defaultEnabled: false
+    // a2a-channel is declared in the registry with defaultEnabled: false
     expect(result.isError).toBe(true);
     expect(result.content).toContain("disabled by feature flag");
   });