@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/__tests__/skills.test.ts

@@ -11,6 +11,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { parse as parseYaml } from "yaml";
+
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
 const noopLogger = {
@@ -252,6 +254,129 @@ describe("workspace skills", () => {
   });
 });
 
+describe("plugin-resident skills", () => {
+  const pluginsDir = join(TEST_DIR, "plugins");
+
+  /**
+   * Materialize a skill on disk inside an installed plugin directory:
+   * `plugins/<plugin>/skills/<skillId>/SKILL.md`. A `package.json` is written
+   * for the plugin by default since that is the install gate the discovery
+   * scan keys on; pass `withPackageJson: false` to simulate a stray directory.
+   */
+  function writePluginSkill(
+    pluginName: string,
+    skillId: string,
+    name: string,
+    description: string,
+    body: string = "Plugin skill body",
+    {
+      withPackageJson = true,
+      packageName,
+    }: { withPackageJson?: boolean; packageName?: string } = {},
+  ): void {
+    const pluginDir = join(pluginsDir, pluginName);
+    mkdirSync(pluginDir, { recursive: true });
+    if (withPackageJson) {
+      writeFileSync(
+        join(pluginDir, "package.json"),
+        JSON.stringify({ name: packageName ?? pluginName, version: "1.0.0" }),
+      );
+    }
+    const skillDir = join(pluginDir, "skills", skillId);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      `---\nname: "${name}"\ndescription: "${description}"\n---\n\n${body}\n`,
+    );
+  }
+
+  beforeEach(() => {
+    mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+  });
+
+  afterEach(() => {
+    for (const dir of [join(TEST_DIR, "skills"), pluginsDir]) {
+      if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("discovers skills shipped inside an installed plugin, attributed to it", () => {
+    writePluginSkill("caveman", "caveman", "Caveman", "Terse mode");
+
+    const skill = loadSkillCatalog().find((s) => s.id === "caveman");
+    expect(skill).toBeDefined();
+    expect(skill!.source).toBe("plugin");
+    expect(skill!.owner).toEqual({ kind: "plugin", id: "caveman" });
+  });
+
+  test("loadSkillBySelector loads a plugin-resident skill body", () => {
+    writePluginSkill(
+      "caveman",
+      "caveman",
+      "Caveman",
+      "Terse mode",
+      "Full plugin skill body",
+    );
+
+    const result = loadSkillBySelector("caveman");
+    expect(result.error).toBeUndefined();
+    expect(result.skill).toBeDefined();
+    expect(result.skill!.source).toBe("plugin");
+    expect(result.skill!.body).toBe("Full plugin skill body");
+    expect(result.skill!.owner).toEqual({ kind: "plugin", id: "caveman" });
+  });
+
+  test("ignores plugin directories without a package.json (staging/stray dirs)", () => {
+    writePluginSkill(
+      "half-installed",
+      "ghost",
+      "Ghost",
+      "Should be skipped",
+      "body",
+      { withPackageJson: false },
+    );
+
+    const skill = loadSkillCatalog().find((s) => s.id === "ghost");
+    expect(skill).toBeUndefined();
+  });
+
+  test("ignores plugin dirs whose package.json name mismatches the directory", () => {
+    // Mirrors the loader's recognition gate: an un-adapted clone whose
+    // package.json declares `caveman-installer` in a `caveman` dir is skipped.
+    writePluginSkill("caveman", "caveman", "Caveman", "Terse mode", "body", {
+      packageName: "caveman-installer",
+    });
+
+    const skill = loadSkillCatalog().find((s) => s.id === "caveman");
+    expect(skill).toBeUndefined();
+  });
+
+  test("workspace skill overrides a plugin-resident skill with the same id", () => {
+    const WORKSPACE_DIR = join(
+      tmpdir(),
+      `vellum-workspace-test-${crypto.randomUUID()}`,
+    );
+    const workspaceSkillsDir = join(WORKSPACE_DIR, ".vellum", "skills");
+    mkdirSync(join(workspaceSkillsDir, "shared-id"), { recursive: true });
+    writeFileSync(
+      join(workspaceSkillsDir, "shared-id", "SKILL.md"),
+      `---\nname: "Workspace Wins"\ndescription: "Workspace version"\n---\n\nbody\n`,
+    );
+    writePluginSkill("caveman", "shared-id", "Plugin Loses", "Plugin version");
+
+    try {
+      const skill = loadSkillCatalog(workspaceSkillsDir).find(
+        (s) => s.id === "shared-id",
+      );
+      expect(skill).toBeDefined();
+      expect(skill!.source).toBe("workspace");
+      expect(skill!.name).toBe("Workspace Wins");
+    } finally {
+      rmSync(WORKSPACE_DIR, { recursive: true, force: true });
+    }
+  });
+});
+
 describe("tool manifest detection", () => {
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
@@ -514,6 +639,83 @@ describe("includes frontmatter parsing", () => {
   });
 });
 
+describe("category frontmatter parsing", () => {
+  beforeEach(() => {
+    mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+  });
+
+  afterEach(() => {
+    const skillsDir = join(TEST_DIR, "skills");
+    if (existsSync(skillsDir))
+      rmSync(skillsDir, { recursive: true, force: true });
+  });
+
+  function writeSkillWithCategory(skillId: string, category: string): void {
+    const skillDir = join(TEST_DIR, "skills", skillId);
+    mkdirSync(skillDir, { recursive: true });
+    const metadata = `{"vellum":{"category":${category}}}`;
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      `---\nname: "${skillId}"\ndescription: "test"\nmetadata: ${metadata}\n---\n\nBody.\n`,
+    );
+  }
+
+  test("parses category from metadata.vellum", () => {
+    writeSkillWithCategory("categorized", '"productivity"');
+    const skill = loadUserSkillCatalog().find((s) => s.id === "categorized");
+    expect(skill!.category).toBe("productivity");
+  });
+
+  test("trims whitespace in category", () => {
+    writeSkillWithCategory("padded", '"  email  "');
+    const skill = loadUserSkillCatalog().find((s) => s.id === "padded");
+    expect(skill!.category).toBe("email");
+  });
+
+  test("returns undefined for empty category", () => {
+    writeSkillWithCategory("empty", '"  "');
+    const skill = loadUserSkillCatalog().find((s) => s.id === "empty");
+    expect(skill!.category).toBeUndefined();
+  });
+
+  test("returns undefined for non-string category", () => {
+    writeSkillWithCategory("numeric", "42");
+    const skill = loadUserSkillCatalog().find((s) => s.id === "numeric");
+    expect(skill!.category).toBeUndefined();
+  });
+
+  test("skill without category has undefined category", () => {
+    writeSkill("no-category", "No Category", "Test");
+    const skill = loadUserSkillCatalog().find((s) => s.id === "no-category");
+    expect(skill!.category).toBeUndefined();
+  });
+});
+
+describe("bundled skill categories", () => {
+  test("every bundled skill declares a valid category slug", () => {
+    const yamlPath = join(
+      import.meta.dir,
+      "..",
+      "..",
+      "..",
+      "skills",
+      "skill-categories-catalog.yaml",
+    );
+    const parsed = parseYaml(readFileSync(yamlPath, "utf-8")) as {
+      categories: { slug: string }[];
+    };
+    const validSlugs = new Set(parsed.categories.map((c) => c.slug));
+    expect(validSlugs.size).toBeGreaterThan(0);
+
+    const bundled = loadSkillCatalog().filter((s) => s.bundled);
+    expect(bundled.length).toBeGreaterThan(0);
+    const invalid = bundled
+      .filter((s) => !s.category || !validSlugs.has(s.category))
+      .map((s) => `${s.id}: ${s.category ?? "(missing)"}`);
+    expect(invalid).toEqual([]);
+  });
+});
+
 describe("managed browser skill", () => {
   const BROWSER_SKILL_MD = readFileSync(
     join(import.meta.dirname, "../../../skills/vellum-browser-use/SKILL.md"),

package/src/__tests__/slim-skill-category.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Category precedence in toSlimSkillResponse (via listSkills):
+ * catalog entry > SKILL.md frontmatter > "system" fallback.
+ */
+import { join } from "node:path";
+import { describe, expect, mock, test } from "bun:test";
+
+import type { SkillSummary } from "../config/skills.js";
+import type { CatalogSkill } from "../skills/catalog-install.js";
+
+let mockSummaries: SkillSummary[] = [];
+let mockCachedCatalog: CatalogSkill[] = [];
+
+// ---------------------------------------------------------------------------
+// Module mocks — must be declared before importing the module under test
+// ---------------------------------------------------------------------------
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}),
+  invalidateConfigCache: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+}));
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => mockSummaries,
+}));
+
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: (catalog: SkillSummary[]) =>
+    catalog.map((summary) => ({ summary, state: "enabled" })),
+  skillFlagKey: () => null,
+}));
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => true,
+}));
+
+mock.module("../skills/install-meta.js", () => ({
+  readInstallMeta: () => null,
+}));
+
+mock.module("../skills/catalog-cache.js", () => ({
+  getCatalog: async () => mockCachedCatalog,
+  getCachedCatalogSync: () => mockCachedCatalog,
+}));
+
+mock.module("../skills/catalog-files.js", () => ({
+  catalogSkillToSlim: () => ({}),
+  createVellumCatalogProvider: () => ({}),
+  hasHiddenOrSkippedSegment: () => false,
+  readCatalogSkillFiles: async () => null,
+  readCatalogSkillFileContent: async () => null,
+  sanitizeRelativePath: (p: string) => p,
+  SKIP_DIRS: new Set(["node_modules", "__pycache__", ".git"]),
+}));
+
+mock.module("../skills/skillssh-files.js", () => ({
+  createSkillsShProvider: () => ({}),
+}));
+
+mock.module("../skills/clawhub-files.js", () => ({
+  createClawhubProvider: () => ({}),
+}));
+
+mock.module("../skills/catalog-install.js", () => ({
+  installSkillLocally: async () => {},
+}));
+
+mock.module("../skills/catalog-search.js", () => ({
+  filterByQuery: () => [],
+}));
+
+mock.module("../skills/clawhub.js", () => ({
+  clawhubCheckUpdates: async () => [],
+  clawhubInspect: async () => ({}),
+  clawhubInstall: async () => ({ success: true }),
+  clawhubSearch: async () => ({ skills: [] }),
+  clawhubUpdate: async () => ({ success: true }),
+}));
+
+mock.module("../skills/skillssh-registry.js", () => ({
+  fetchSkillAudits: async () => [],
+  installExternalSkill: async () => {},
+  resolveSkillSource: () => ({ owner: "", repo: "", skillSlug: "" }),
+  searchSkillsRegistry: async () => [],
+}));
+
+mock.module("../skills/managed-store.js", () => ({
+  createManagedSkill: () => ({ created: true }),
+  deleteManagedSkill: () => ({ deleted: true }),
+  validateManagedSkillId: () => null,
+}));
+
+mock.module("../memory/graph/capability-seed.js", () => ({
+  deleteSkillCapabilityNode: () => {},
+  seedSkillGraphNodes: () => {},
+  seedUninstalledCatalogSkillMemories: async () => {},
+}));
+
+mock.module("../providers/provider-send-message.js", () => ({
+  createTimeout: () => ({
+    signal: AbortSignal.timeout(1000),
+    cleanup: () => {},
+  }),
+  extractText: () => "",
+  getConfiguredProvider: async () => null,
+  userMessage: () => ({}),
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspaceSkillsDir: () => "/tmp/test-skills-category",
+}));
+
+mock.module("../daemon/handlers/shared.js", () => ({
+  CONFIG_RELOAD_DEBOUNCE_MS: 100,
+  ensureSkillEntry: () => ({ enabled: false }),
+  log: {
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { listSkills } from "../daemon/handlers/skills.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeSummary(overrides: Partial<SkillSummary>): SkillSummary {
+  const directoryPath = overrides.directoryPath ?? "/tmp/nonexistent-skill-dir";
+  return {
+    id: overrides.id ?? "summary-id",
+    name: overrides.id ?? "summary-id",
+    displayName: overrides.displayName ?? "Summary",
+    description: "",
+    directoryPath,
+    skillFilePath: join(directoryPath, "SKILL.md"),
+    source: overrides.source ?? "bundled",
+    bundled: overrides.source !== "managed",
+    category: overrides.category,
+  };
+}
+
+function makeCatalogSkill(id: string, category: string): CatalogSkill {
+  return {
+    id,
+    name: id,
+    description: "",
+    metadata: { vellum: { category } },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("listSkills — category precedence", () => {
+  test("catalog category wins over frontmatter category", () => {
+    mockSummaries = [makeSummary({ id: "gmail", category: "messaging" })];
+    mockCachedCatalog = [makeCatalogSkill("gmail", "email")];
+
+    const [skill] = listSkills();
+    expect(skill.category).toBe("email");
+  });
+
+  test("frontmatter category used when skill is not in the catalog", () => {
+    mockSummaries = [makeSummary({ id: "schedule", category: "productivity" })];
+    mockCachedCatalog = [];
+
+    const [skill] = listSkills();
+    expect(skill.category).toBe("productivity");
+  });
+
+  test("falls back to system when neither catalog nor frontmatter declare a category", () => {
+    mockSummaries = [makeSummary({ id: "mystery" })];
+    mockCachedCatalog = [];
+
+    const [skill] = listSkills();
+    expect(skill.category).toBe("system");
+  });
+});

package/src/__tests__/strip-memory-injections.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, test } from "bun:test";
 
-import {
-  stripAllMemoryInjections,
-  stripExistingMemoryInjections,
-} from "../memory/graph/conversation-graph-memory.js";
+import { stripSpotlightInjections } from "../context/strip-injections.js";
+import { stripExistingMemoryInjections } from "../memory/graph/conversation-graph-memory.js";
+import { wrapMemorySpotlightBlock } from "../memory/memory-marker.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -204,8 +203,8 @@ describe("stripExistingMemoryInjections", () => {
     expect(result[0].content).toEqual([textBlock("hello")]);
   });
 
-  // Regression guard: the v2 helper must remain last-message-only even after
-  // the shared per-message strip is extracted for stripAllMemoryInjections.
+  // Regression guard: the helper must remain last-message-only — memory-v3's
+  // frozen-card carry depends on historical `<memory>` blocks staying intact.
   test("strips ONLY the last user message, leaving earlier ones injected", () => {
     const messages = [
       userMsg(memoryTextBlock, textBlock("first")),
@@ -221,55 +220,50 @@ describe("stripExistingMemoryInjections", () => {
 });
 
 // ---------------------------------------------------------------------------
-// stripAllMemoryInjections — removes memory-injected blocks from EVERY user
-// message (memory-v3 live mode). Reuses the same per-message strip logic.
+// stripSpotlightInjections — the memory-v3 ephemeral spotlight is the ONLY
+// block strip-and-replaced across every user message each turn. Frozen
+// `<memory>` card blocks must never be touched by it (the cache contract);
+// the old whole-layer stripAllMemoryInjections replace is gone.
 // ---------------------------------------------------------------------------
 
-describe("stripAllMemoryInjections", () => {
-  test("strips memory blocks from multiple historical user messages", () => {
+const spotlightBlock = (inner: string): ContentBlock => ({
+  type: "text",
+  text: wrapMemorySpotlightBlock(inner),
+});
+
+describe("stripSpotlightInjections", () => {
+  test("strips spotlight blocks from every user message, leaving <memory> blocks intact", () => {
     const messages = [
-      userMsg(memoryTextBlock, textBlock("first")),
+      userMsg(memoryTextBlock, textBlock("first"), spotlightBlock("s1")),
       assistantMsg("ok"),
-      userMsg(
-        memoryImageMarker,
-        memoryImage,
-        memoryImageClose,
-        memoryTextBlock,
-        textBlock("second"),
-      ),
-      assistantMsg("sure"),
-      userMsg(memoryTextBlock, textBlock("third")),
+      userMsg(memoryTextBlock, textBlock("second"), spotlightBlock("s2")),
     ];
-    const result = stripAllMemoryInjections(messages);
-    expect(result[0].content).toEqual([textBlock("first")]);
+    const result = stripSpotlightInjections(messages);
+    expect(result[0].content).toEqual([memoryTextBlock, textBlock("first")]);
     expect(result[1]).toBe(messages[1]); // assistant message untouched
-    expect(result[2].content).toEqual([textBlock("second")]);
-    expect(result[3]).toBe(messages[3]);
-    expect(result[4].content).toEqual([textBlock("third")]);
+    expect(result[2].content).toEqual([memoryTextBlock, textBlock("second")]);
   });
 
-  test("preserves non-memory content and user-attached images", () => {
-    const messages = [
-      userMsg(memoryTextBlock, imageBlock, textBlock("what is this?")),
-      userMsg(textBlock("plain message")),
-    ];
-    const result = stripAllMemoryInjections(messages);
-    expect(result[0].content).toEqual([imageBlock, textBlock("what is this?")]);
-    expect(result[1].content).toEqual([textBlock("plain message")]);
+  test("requires the full wrapper: user text merely starting with the tag survives", () => {
+    const lookalike = textBlock("<memory_spotlight>\nnot really a block");
+    const messages = [userMsg(lookalike, textBlock("hello"))];
+    const result = stripSpotlightInjections(messages);
+    expect(result[0].content).toEqual([lookalike, textBlock("hello")]);
   });
 
-  test("no-op (same reference) when no user message carries a memory block", () => {
+  test("content no-op when no spotlight blocks exist", () => {
     const messages = [
-      userMsg(textBlock("hello")),
+      userMsg(memoryTextBlock, textBlock("hello")),
       assistantMsg("hi"),
       userMsg(imageBlock),
     ];
-    const result = stripAllMemoryInjections(messages);
-    expect(result).toBe(messages);
+    const result = stripSpotlightInjections(messages);
+    expect(result).toEqual(messages);
+    // Untouched messages keep their identity (cheap no-op detection upstream).
+    expect(result[0]).toBe(messages[0]);
   });
 
   test("no-op for empty messages array", () => {
-    const result = stripAllMemoryInjections([]);
-    expect(result).toEqual([]);
+    expect(stripSpotlightInjections([])).toEqual([]);
   });
 });

package/src/__tests__/test-support/tool-invocation-seed.ts

@@ -0,0 +1,79 @@
+// Per the test-machinery isolation rule in assistant/AGENTS.md, this shared
+// helper has no runtime imports from src/ — the importing test files (which
+// may import production modules like any normal consumer) pass the db handle
+// and table objects in. The imports below are type-only and fully erased at
+// compile time, so loading this module has no side effects.
+import type { getDb } from "../../memory/db-connection.js";
+import type { conversations, toolInvocations } from "../../memory/schema.js";
+
+/**
+ * Sentinel embedded in the seeded raw input/result payloads. Tests assert it
+ * never appears in any projection or wire payload — raw tool args/outputs
+ * must never leave the device.
+ */
+export const TOOL_INVOCATION_PII_SENTINEL = "must never leave the device";
+
+/** Production handles supplied by the importing test file. */
+export interface ToolInvocationSeedDeps {
+  db: ReturnType<typeof getDb>;
+  conversations: typeof conversations;
+  toolInvocations: typeof toolInvocations;
+}
+
+export interface ToolInvocationSeedSpec {
+  id: string;
+  createdAt: number;
+  conversationId: string;
+  toolName?: string;
+  decision?: string;
+  durationMs?: number;
+  argBytes?: number | null;
+  resultBytes?: number | null;
+  provider?: string | null;
+  model?: string | null;
+  inferenceProfile?: string | null;
+  inferenceProfileSource?: string | null;
+}
+
+/**
+ * Seed a `tool_invocations` row (plus its FK conversation) for telemetry
+ * projection tests. Byte sizes default to non-null — post-migration writer
+ * paths always compute them; pass an explicit null to seed a legacy
+ * pre-migration-278 row.
+ */
+export function seedToolInvocation(
+  deps: ToolInvocationSeedDeps,
+  spec: ToolInvocationSeedSpec,
+): void {
+  // tool_invocations has an enforced FK to conversations.
+  deps.db
+    .insert(deps.conversations)
+    .values({
+      id: spec.conversationId,
+      title: "test",
+      createdAt: 1000,
+      updatedAt: 1000,
+    })
+    .onConflictDoNothing()
+    .run();
+  deps.db
+    .insert(deps.toolInvocations)
+    .values({
+      id: spec.id,
+      conversationId: spec.conversationId,
+      toolName: spec.toolName ?? "calendar_list_events",
+      input: `{"secret":"raw tool args — ${TOOL_INVOCATION_PII_SENTINEL}"}`,
+      result: `{"secret":"raw tool output — ${TOOL_INVOCATION_PII_SENTINEL}"}`,
+      decision: spec.decision ?? "allow",
+      riskLevel: "low",
+      durationMs: spec.durationMs ?? 12,
+      createdAt: spec.createdAt,
+      argBytes: spec.argBytes !== undefined ? spec.argBytes : 2,
+      resultBytes: spec.resultBytes !== undefined ? spec.resultBytes : 9,
+      provider: spec.provider ?? null,
+      model: spec.model ?? null,
+      inferenceProfile: spec.inferenceProfile ?? null,
+      inferenceProfileSource: spec.inferenceProfileSource ?? null,
+    })
+    .run();
+}

package/src/__tests__/title-generate-hook.test.ts

@@ -78,6 +78,8 @@ function makeCtx(
     conversationId: "conv-1",
     userMessageId: "msg-1",
     requestId: "req-1",
+    modelProfileKey: null,
+    isNonInteractive: false,
     prompt: "first message",
     originalMessages: messages,
     latestMessages: messages,
@@ -121,9 +123,7 @@ function makeStopCtx(overrides: Partial<StopContext> = {}): StopContext {
   return {
     conversationId: "conv-1",
     messages: historyWithUserTurns(3),
-    responseContent: [{ type: "text", text: "reply 3" }],
-    stopReason: "end_turn",
-    decision: "stop",
+    exitReason: "no_tool_calls",
     logger: noopLogger,
     ...overrides,
   };
@@ -273,18 +273,20 @@ describe("title-generate stop hook", () => {
     expect(queueRegenerateConversationTitleMock).toHaveBeenCalledTimes(1);
   });
 
-  test("defers when an earlier hook chose to continue the run", async () => {
-    // GIVEN a third-user-turn stop that an earlier hook flipped to "continue"
+  test("does not regenerate on a non-success terminal exit", async () => {
+    // GIVEN a third-user-turn stop that ended on a provider error rather than
+    // a finalized no-tool reply
     const ctx = makeStopCtx({
       messages: historyWithUserTurns(3),
-      decision: "continue",
+      exitReason: "error",
+      error: new Error("provider rejected"),
     });
 
     // WHEN the stop hook runs and any deferred work flushes
     await stop(ctx);
     await flushMacrotasks();
 
-    // THEN it defers to the eventual terminal stop rather than re-titling now
+    // THEN no regeneration fires — there is no new topic to re-title from
     expect(queueRegenerateConversationTitleMock).toHaveBeenCalledTimes(0);
   });