@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/plugins/defaults/memory/hooks/user-prompt-submit.ts

@@ -53,6 +53,7 @@ import type { GraphMemoryResult } from "../graph/conversation-graph-memory.js";
 import { recordMemoryRecallLog } from "../memory-recall-log-store.js";
 import { stripTailInjectionsForReinjection } from "../tail-reinjection-strip.js";
 import { MEMORY_V3_INJECTED_BLOCK_METADATA_KEY } from "../v3/ever-injected-store.js";
+import { MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY } from "../v3/types.js";
 
 /**
  * Whether to run legacy graph-memory retrieval this turn. It gates BOTH
@@ -220,6 +221,10 @@ async function recordRecallSideEffects(
  *  - `blocks.memoryV3InjectedBlock` (the frozen net-new card block, unwrapped)
  *    persists under `MEMORY_V3_INJECTED_BLOCK_METADATA_KEY`; `loadFromDb`
  *    re-wraps and splices it on load, freezing the cards into history.
+ *  - `blocks.memoryV3SpotlightBlock` (the wrapped `<memory_spotlight>` that
+ *    was sent) persists under `MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY`;
+ *    `loadFromDb` splices it back onto the same row so historical turns
+ *    keep the spotlight they were sent with.
  */
 async function persistInjectionBlocks(
   blocks: RuntimeInjectionResult["blocks"],
@@ -235,6 +240,7 @@ async function persistInjectionBlocks(
     !blocks.pkbContextBlock &&
     !blocks.memoryV2StaticBlock &&
     !blocks.memoryV3InjectedBlock &&
+    !blocks.memoryV3SpotlightBlock &&
     !blocks.backgroundTurnBlock &&
     !blocks.channelCapabilitiesBlock &&
     !blocks.nonInteractiveContextBlock &&
@@ -255,6 +261,10 @@ async function persistInjectionBlocks(
       metadataUpdates[MEMORY_V3_INJECTED_BLOCK_METADATA_KEY] =
         blocks.memoryV3InjectedBlock;
     }
+    if (blocks.memoryV3SpotlightBlock) {
+      metadataUpdates[MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY] =
+        blocks.memoryV3SpotlightBlock;
+    }
     if (blocks.unifiedTurnContext) {
       metadataUpdates.turnContextBlock = blocks.unifiedTurnContext;
     }

package/src/plugins/defaults/memory/injectors.ts

@@ -428,7 +428,7 @@ export const memoryInjectors: Injector[] = [
   // `memory-v2-static` is FROZEN: `daemon/conversation-runtime-assembly.ts`
   // switches on it to capture the block into persisted message metadata.
   memoryV2StaticInjector,
-  // V3 — delete with v3. The frozen net-new card block and its ephemeral
+  // V3: delete with v3. The frozen net-new card block and its per-turn
   // spotlight companion; both self-gate on `memory.v3.live`.
   memoryV3Injector,
   memoryV3SpotlightInjector,

package/src/plugins/defaults/memory/memory-marker.ts

@@ -30,13 +30,11 @@ export function unwrapMemoryBlock(block: string): string {
 }
 
 /**
- * The memory-v3 ephemeral spotlight wrapper. Unlike `<memory>` card blocks
- * (frozen into history), the spotlight block is re-rendered onto the current
- * user tail every turn: the per-turn scoped strip in
- * `context/strip-injections.ts` (`stripSpotlightInjections`) and the
- * compaction matcher in `RUNTIME_INJECTION_PREFIXES` both key off this exact
- * prefix/suffix pair, so the producer wrapper lives here beside the `<memory>`
- * marker it parallels.
+ * The memory-v3 per-turn spotlight wrapper. Each turn's `<memory_spotlight>`
+ * stays on the user message that was sent, matching frozen `<memory>` cards.
+ * Compaction still strips these blocks via `RUNTIME_INJECTION_PREFIXES`, and
+ * `stripSpotlightInjections` is the full-history leftover cleanup used there.
+ * The producer wrapper lives here beside the `<memory>` marker it parallels.
  */
 export const MEMORY_SPOTLIGHT_PREFIX = "<memory_spotlight>\n";
 export const MEMORY_SPOTLIGHT_SUFFIX = "\n</memory_spotlight>";
@@ -44,3 +42,15 @@ export const MEMORY_SPOTLIGHT_SUFFIX = "\n</memory_spotlight>";
 export function wrapMemorySpotlightBlock(text: string): string {
   return `${MEMORY_SPOTLIGHT_PREFIX}${text}${MEMORY_SPOTLIGHT_SUFFIX}`;
 }
+
+/**
+ * Whether `text` is a complete `<memory_spotlight>…</memory_spotlight>`
+ * wrapper. Requires both ends so user-authored text that merely opens with
+ * the tag is not treated as an injected spotlight.
+ */
+export function isMemorySpotlightText(text: string): boolean {
+  return (
+    text.startsWith(MEMORY_SPOTLIGHT_PREFIX) &&
+    text.endsWith(MEMORY_SPOTLIGHT_SUFFIX)
+  );
+}

package/src/plugins/defaults/memory/substrate/__tests__/consolidation-prompt-flag-gating-guard.test.ts

@@ -103,12 +103,8 @@ function loadDefaultDisabledAssistantFlagKeys(): string[] {
     .sort();
 }
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 function featureFlagKeyPattern(key: string): RegExp {
-  const escaped = escapeRegExp(key);
+  const escaped = RegExp.escape(key);
   if (key.includes("-")) {
     return new RegExp(`(?:^|[^a-z0-9-])${escaped}(?:$|[^a-z0-9-])`, "i");
   }

package/src/plugins/defaults/memory/substrate/__tests__/skill-content.test.ts

@@ -119,3 +119,20 @@ describe("augmentMcpSetupDescription", () => {
     expect(out.id).toBe("mcp-setup");
   });
 });
+
+describe("SKILLS_INJECTION_CATALOG_HINT", () => {
+  test("points a missing product at plugin and skill search", async () => {
+    const { SKILLS_INJECTION_CATALOG_HINT } = await import(
+      "../skill-content.js"
+    );
+    expect(SKILLS_INJECTION_CATALOG_HINT).toContain(
+      "assistant plugins search <name>",
+    );
+    expect(SKILLS_INJECTION_CATALOG_HINT).toContain(
+      "assistant skills search <name>",
+    );
+    expect(SKILLS_INJECTION_CATALOG_HINT.toLowerCase()).toContain(
+      "currently in the workspace",
+    );
+  });
+});

package/src/plugins/defaults/memory/substrate/skill-content.ts

@@ -29,6 +29,13 @@ export const ALWAYS_CANDIDATE_CARD_CHARS = 900;
  */
 export const DEFAULT_CARD_CHARS = 500;
 
+/**
+ * One-shot line under injected skill cards. The cards list workspace skills
+ * only, so a missing product is not evidence it is unsupported.
+ */
+export const SKILLS_INJECTION_CATALOG_HINT =
+  "Injected skills are only ones currently in the workspace. Run `assistant plugins search <name>` and `assistant skills search <name>` before concluding a given integration or skill is unsupported";
+
 /**
  * Render the prose-style capability statement embedded into the unified
  * `memory_v2_concept_pages` Qdrant collection (under the `skills/<id>` slug

package/src/plugins/defaults/memory/v3/__tests__/carry-integration.test.ts

@@ -12,11 +12,11 @@
  *     → selectPool (real two-segment render + cache breakpoint; the PROVIDER
  *       is stubbed to return deterministic ids per scripted turn)
  *     → the real injectors (`memoryV3Injector` net-new cards + recordInjected
- *       + schedulePruneValve; `memoryV3SpotlightInjector` ephemeral window)
- *     → simulated runtime assembly (splice the card block onto the current
- *       user message; scoped spotlight strip-and-replace via the real
- *       `stripSpotlightInjections`) and metadata persistence (the
- *       user-prompt-submit hook's `memoryV3InjectedBlock` write)
+ *       + schedulePruneValve; `memoryV3SpotlightInjector` per-turn window)
+ *     → simulated runtime assembly (splice the card block and the
+ *       spotlight onto the current user message; do not rewrite historical
+ *       spotlights) and metadata persistence (the user-prompt-submit
+ *       hook's `memoryV3InjectedBlock` and `memoryV3SpotlightBlock` writes)
  *     → the real prune valve against the live history (conversation-registry
  *       stubbed to the simulated message arrays)
  *     → rehydration from the temp DB (mirroring `daemon/conversation.ts`'s
@@ -57,7 +57,6 @@ import type {
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { setConfig } from "../../../../../__tests__/helpers/set-config.js";
-import { stripSpotlightInjections } from "../../../../../context/strip-injections.js";
 import { ensureMemoryV3SelectionsSchema } from "../../../../../persistence/migrations/338-move-memory-v3-selections-to-memory-db.js";
 import { ensureMemoryV3EverInjectedSchema } from "../../../../../persistence/migrations/345-move-memory-v3-ever-injected-to-memory-db.js";
 import * as schema from "../../../../../persistence/schema/index.js";
@@ -71,6 +70,7 @@ import { buildSectionNeedle } from "../section-needle.js";
 import { buildSectionIndex } from "../sections.js";
 import {
   MEMORY_V3_COMMIT_META_KEY,
+  MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY,
   type SectionIndex,
   type Slug,
 } from "../types.js";
@@ -561,7 +561,7 @@ interface TurnRecord {
   spotlightPlacement: string;
   residentBytes: number;
   prunedSlugs: Set<string>;
-  /** JSON of the spotlight-stripped (persistent-layer) history after the turn. */
+  /** JSON of the live history after the turn (cards + spotlight persist). */
   snapshot: string;
 }
 
@@ -583,7 +583,7 @@ function insertMessageRow(
 }
 
 function persistentView(history: Message[]): string {
-  return JSON.stringify(stripSpotlightInjections(history));
+  return JSON.stringify(history);
 }
 
 async function runTurn(
@@ -646,29 +646,34 @@ async function runTurn(
   if (cards.text.length > 0) {
     const tail = history[history.length - 1]!;
     tail.content = [{ type: "text", text: cards.text }, ...tail.content];
-    testSqlite
-      .query(/*sql*/ `UPDATE messages SET metadata = ? WHERE id = ?`)
-      .run(
-        JSON.stringify({
-          [MEMORY_V3_INJECTED_BLOCK_METADATA_KEY]: unwrapMemoryBlock(
-            cards.text,
-          ),
-        }),
-        userRowId,
-      );
   }
 
-  // Spotlight: scoped strip of the stale block (real assembly helper), then
-  // re-attach the fresh one. Real assembly splices it after the memory cards
-  // (after-memory-prefix); this sim appends to the tail because only the
-  // block's presence, content, placement value, and strip-and-replace are
-  // asserted here — not its exact position within the message.
+  // Spotlight splices after the frozen cards (after-memory-prefix). Historical
+  // user messages keep the spotlight they already carry.
   const spotlight = await memoryV3SpotlightInjector.produce(ctx);
-  const stripped = stripSpotlightInjections(history);
-  history.splice(0, history.length, ...stripped);
-  if (spotlight) {
+  if (spotlight && spotlight.text.length > 0) {
     const tail = history[history.length - 1]!;
-    tail.content = [...tail.content, { type: "text", text: spotlight.text }];
+    const prefixCount = cards.text.length > 0 ? 1 : 0;
+    tail.content = [
+      ...tail.content.slice(0, prefixCount),
+      { type: "text", text: spotlight.text },
+      ...tail.content.slice(prefixCount),
+    ];
+  }
+
+  const metadata: Record<string, string> = {};
+  if (cards.text.length > 0) {
+    metadata[MEMORY_V3_INJECTED_BLOCK_METADATA_KEY] = unwrapMemoryBlock(
+      cards.text,
+    );
+  }
+  if (spotlight?.text) {
+    metadata[MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY] = spotlight.text;
+  }
+  if (Object.keys(metadata).length > 0) {
+    testSqlite
+      .query(/*sql*/ `UPDATE messages SET metadata = ? WHERE id = ?`)
+      .run(JSON.stringify(metadata), userRowId);
   }
 
   const replyContent: ContentBlock[] = [
@@ -726,6 +731,10 @@ function rehydrateFromDb(convId: string): Message[] {
     let content = JSON.parse(row.content) as ContentBlock[];
     if (row.role === "user" && row.metadata) {
       const meta = JSON.parse(row.metadata) as Record<string, unknown>;
+      const spotlight = meta[MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY];
+      if (typeof spotlight === "string") {
+        content = [{ type: "text", text: spotlight }, ...content];
+      }
       const block = meta[MEMORY_V3_INJECTED_BLOCK_METADATA_KEY];
       if (typeof block === "string") {
         const resident = filterPrunedCardSections(
@@ -1014,7 +1023,7 @@ describe("memory-v3 carry integration — cache contract", () => {
 });
 
 describe("memory-v3 carry integration — spotlight contract", () => {
-  test("spotlight is present every turn, after the memory cards, bounded by n × (window + 1)", () => {
+  test("spotlight is produced every turn, spliced after cards, bounded by n × (window + 1)", () => {
     for (const record of records) {
       expect(record.spotlightText.startsWith("<memory_spotlight>\n")).toBe(
         true,
@@ -1040,12 +1049,9 @@ describe("memory-v3 carry integration — spotlight contract", () => {
     expect(records[5]!.spotlightText).not.toContain("page-a.md");
   });
 
-  test("the spotlight never reaches the persistent layer (blocks, metadata, history)", () => {
+  test("each turn persists its spotlight on that user message and keeps historical copies", () => {
     for (const record of records) {
       expect(record.blockText).not.toContain("<memory_spotlight>");
-      // The persistent-layer snapshot is spotlight-stripped by construction;
-      // the raw live history must carry exactly ONE spotlight block (the
-      // current turn's).
     }
     const metadataRows = testSqlite
       .query(
@@ -1056,9 +1062,10 @@ describe("memory-v3 carry integration — spotlight contract", () => {
       )
       .all(CONV) as Array<{ metadata: string }>;
     expect(metadataRows.length).toBeGreaterThan(0);
-    for (const row of metadataRows) {
-      expect(row.metadata).not.toContain("memory_spotlight");
-    }
+    const persistedSpotlights = metadataRows.filter((row) =>
+      row.metadata.includes(MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY),
+    );
+    expect(persistedSpotlights.length).toBeGreaterThan(1);
     const liveSpotlights = histories
       .get(CONV)!
       .flatMap((m) => m.content)
@@ -1066,7 +1073,7 @@ describe("memory-v3 carry integration — spotlight contract", () => {
         (b): b is { type: "text"; text: string } =>
           b.type === "text" && b.text.startsWith("<memory_spotlight>\n"),
       );
-    expect(liveSpotlights).toHaveLength(1);
+    expect(liveSpotlights.length).toBeGreaterThan(1);
   });
 });
 
@@ -1106,15 +1113,21 @@ describe("memory-v3 carry integration — restart contract", () => {
 
   test("pruned sections are absent from the rehydrated history (metadata stays intact)", () => {
     const rehydrated = JSON.parse(restartRehydratedJson) as Message[];
-    const allText = rehydrated
+    const cardText = rehydrated
       .flatMap((m) => m.content)
       .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .filter(
+        (b) =>
+          b.text.startsWith("<memory>\n") && b.text.endsWith("\n</memory>"),
+      )
       .map((b) => b.text)
       .join("\n");
-    expect(allText).not.toContain("# memory/concepts/page-a.md");
-    expect(allText).not.toContain("# memory/concepts/page-b.md");
-    // Resident cards survive the round trip…
-    expect(allText).toContain(card("page-c"));
+    // Prune filters card sections on rehydrate. Historical spotlights stay
+    // as sent, so a pruned slug can still appear under `##` in those blocks.
+    expect(cardText).not.toContain("# memory/concepts/page-a.md");
+    expect(cardText).not.toContain("# memory/concepts/page-b.md");
+    // Resident cards survive the round trip.
+    expect(cardText).toContain(card("page-c"));
     // …and the persisted metadata still carries the pruned cards (the filter
     // is rehydration-time, never a metadata rewrite).
     const metadata = testSqlite

package/src/plugins/defaults/memory/v3/__tests__/injection.test.ts

@@ -1,6 +1,6 @@
 /**
  * Tests for the memory-v3 injection layer (`injector.ts`): frozen net-new
- * cards + ephemeral spotlight.
+ * cards + per-turn spotlight.
  *
  *   - net-new dedup: a turn re-selecting already-injected pages renders zero
  *     new cards (empty-text block — still produced, so v2 suppression holds);
@@ -613,14 +613,14 @@ describe("memoryV3Injector — frozen net-new cards", () => {
   });
 });
 
-// ─── ephemeral spotlight ────────────────────────────────────────────────────
+// ─── per-turn spotlight ─────────────────────────────────────────────────────
 
 describe("memoryV3SpotlightInjector — ephemeral section spotlight", () => {
   const sectionA = section("page-a", "Alpha", "alpha section text");
   const sectionB = section("page-b", "Beta", "beta section text");
   const sectionC = section("page-c", "Gamma", "gamma section text");
 
-  test("renders selected finder hits' matched sections right after the memory cards", async () => {
+  test("renders selected finder hits' matched sections as an after-memory-prefix spotlight", async () => {
     liveEnabled = true;
     turnResults.set(0, result(["page-a", "page-b"], [["page-a", sectionA]]));
 

package/src/plugins/defaults/memory/v3/__tests__/render-injection.test.ts

@@ -36,6 +36,28 @@ describe("renderCardsBlockInner", () => {
   test("empty card list renders the empty string (no header-only block)", () => {
     expect(renderCardsBlockInner([])).toBe("");
   });
+
+  test("skill cards get a one-shot catalog hint that is not a concept card", () => {
+    const inner = renderCardsBlockInner([
+      "# Skill: telegram-setup\nSet up Telegram.",
+      "# memory/concepts/page-a.md\nhead a",
+    ]);
+    expect(inner).toContain(V3_CARDS_INJECTION_HEADER);
+    expect(inner).toContain("# Skills\n");
+    expect(inner).toContain("assistant plugins search <name>");
+    expect(inner).toContain("assistant skills search <name>");
+    expect(inner).toContain("currently in the workspace");
+    expect(inner.indexOf("# Skills")).toBeLessThan(inner.indexOf("# Skill:"));
+    expect(inner.startsWith(`${V3_CARDS_INJECTION_HEADER}\n\n# Skills\n`)).toBe(
+      true,
+    );
+  });
+
+  test("concept-only cards omit the skill catalog hint", () => {
+    const inner = renderCardsBlockInner(["# memory/concepts/page-a.md\nhead a"]);
+    expect(inner).not.toContain("# Skills\n");
+    expect(inner).not.toContain("assistant plugins search");
+  });
 });
 
 describe("renderSpotlightInner", () => {

package/src/plugins/defaults/memory/v3/injector.ts

@@ -1,5 +1,5 @@
 /**
- * The memory-v3 {@link Injector}s: frozen net-new cards + ephemeral spotlight.
+ * The memory-v3 {@link Injector}s: frozen net-new cards + per-turn spotlight.
  *
  * Two injectors share one orchestration result per turn (memoized via
  * {@link observeTurnOnce} so re-entry assemblies — overflow convergence,
@@ -30,15 +30,18 @@
  *    frozen cards still ride history).
  *
  *  - {@link memoryV3SpotlightInjector} (id `memory-v3-spotlight`,
- *    `after-memory-prefix`): the EPHEMERAL layer. Renders the top `spotlight.n`
- *    selected finder hits' matched sections, plus the previous
+ *    `after-memory-prefix`): the per-turn spotlight layer. Renders the top
+ *    `spotlight.n` selected finder hits' matched sections, plus the previous
  *    `spotlight.windowTurns` turns' entries from an in-memory per-conversation
  *    ring (a daemon restart simply re-warms it), as a `<memory_spotlight>`
- *    block spliced immediately after the `<memory>` cards block (so the two
- *    memory layers sit adjacent in the prefix, ahead of the user's message
- *    text). Assembly strip-and-replaces this block every turn (scoped to this
- *    block id only); it is never persisted to metadata, so the frozen card
- *    prefix it follows stays byte-stable and cached regardless.
+ *    block. Runtime assembly splices the block onto the current user message
+ *    immediately after any frozen `<memory>` cards. The user-prompt-submit
+ *    hook persists the wrapped text under `metadata.memoryV3SpotlightBlock`;
+ *    `conversation.ts` rehydrates it on load. Historical user messages keep
+ *    the spotlight they were sent with, so the provider prefix through those
+ *    messages stays byte-identical. Mid-turn re-entry and post-compact
+ *    tail-strip the current tail before splicing a fresh spotlight so the
+ *    block does not double-stack.
  *
  * Gating: `memory.v3.live` (config) runs orchestration and attaches blocks;
  * with it off, no orchestration runs and nothing is attached.
@@ -442,13 +445,9 @@ export const memoryV3SpotlightInjector: Injector = {
       return {
         id: MEMORY_V3_SPOTLIGHT_BLOCK_ID,
         text: wrapMemorySpotlightBlock(renderSpotlightInner(window)),
-        // Splices right after the `<memory>` cards block (this injector's
-        // order 1001 runs after the cards' 1000, and `countMemoryPrefixBlocks`
-        // counts the cards `<memory>` block but not `<memory_spotlight>`, so the
-        // spotlight lands immediately after the cards rather than at the user
-        // tail). Cache-neutral: the block is strip-and-replaced from prior
-        // messages by block id every turn regardless of placement, so the
-        // frozen card prefix stays byte-stable and cached.
+        // Immediately after frozen `<memory>` cards. `countMemoryPrefixBlocks`
+        // counts `<memory>` but not `<memory_spotlight>`, so this lands
+        // between the cards and NOW.md / user text.
         placement: "after-memory-prefix",
       };
     } catch (err) {

package/src/plugins/defaults/memory/v3/prune.test.ts

@@ -190,6 +190,18 @@ describe("parseCardSections / filterPrunedCardSections", () => {
     expect(parsed.sections[1]!.text).toBe(card("page-b"));
   });
 
+  test("skill catalog hint is a non-card piece and leaves the read-affordance preamble intact", () => {
+    const mixed = renderCardsBlockInner([
+      "# Skill: telegram-setup\nSet up Telegram.",
+      card("page-a"),
+    ]);
+    const parsed = parseCardSections(mixed);
+    expect(parsed.preamble).toBe(V3_CARDS_INJECTION_HEADER);
+    expect(parsed.sections.map((s) => s.slug)).toEqual(["page-a"]);
+    expect(parsed.pieces.some((piece) => piece.kind === "other")).toBe(true);
+    expect(mixed).toContain("assistant plugins search <name>");
+  });
+
   test("no pruned slug present → returns the SAME reference (no-op)", () => {
     expect(filterPrunedCardSections(inner, new Set(["page-z"]))).toBe(inner);
     expect(filterPrunedCardSections(inner, new Set())).toBe(inner);
@@ -228,8 +240,14 @@ describe("parseCardSections / filterPrunedCardSections", () => {
     expect(parsed.sections.map((s) => s.slug)).toEqual(["page-a", "page-b"]);
     // page-a's section stops AT the capability header — it must not absorb it.
     expect(parsed.sections[0]!.text).toBe(card("page-a"));
-    expect(parsed.pieces.map((p) => p.kind)).toEqual(["card", "other", "card"]);
-    expect(parsed.pieces[1]!.text).toBe(CAPABILITY_CHUNK);
+    expect(parsed.pieces.map((p) => p.kind)).toEqual([
+      "other",
+      "card",
+      "other",
+      "card",
+    ]);
+    expect(parsed.pieces[0]!.text).toContain("assistant plugins search <name>");
+    expect(parsed.pieces[2]!.text).toBe(CAPABILITY_CHUNK);
   });
 
   test("pruning a concept card never swallows a trailing capability chunk", () => {

package/src/plugins/defaults/memory/v3/render-injection.ts

@@ -1,6 +1,10 @@
 import { wrapMemoryBlock } from "../memory-marker.js";
+import { SKILLS_INJECTION_CATALOG_HINT } from "../substrate/skill-content.js";
 import { Section, Slug } from "./types.js";
 
+/** Own `# ` chunk so prune treats the catalog hint as a non-card piece. */
+const SKILLS_CATALOG_HINT_CHUNK = `# Skills\n${SKILLS_INJECTION_CATALOG_HINT}`;
+
 /**
  * Leading instruction line of the frozen card block — byte-identical to v2's
  * `INJECTION_HEADER` (`memory/v2/injection.ts`) so the read affordance the
@@ -23,7 +27,12 @@ export function renderCardsBlockInner(cards: string[]): string {
   if (cards.length === 0) {
     return "";
   }
-  return [V3_CARDS_INJECTION_HEADER, ...cards].join("\n\n");
+  const parts = [V3_CARDS_INJECTION_HEADER];
+  if (cards.some((card) => card.startsWith("# Skill:"))) {
+    parts.push(SKILLS_CATALOG_HINT_CHUNK);
+  }
+  parts.push(...cards);
+  return parts.join("\n\n");
 }
 
 /**

package/src/plugins/defaults/memory/v3/types.ts

@@ -23,13 +23,24 @@ export const MEMORY_V3_BLOCK_ID = "memory-v3" as const;
 export const MEMORY_V3_COMMIT_META_KEY = "memoryV3Commit" as const;
 
 /**
- * Injection-block id for the v3 ephemeral `<memory_spotlight>` block (the
- * current window's matched sections, re-rendered at the user tail each turn).
- * Distinct from {@link MEMORY_V3_BLOCK_ID}: the spotlight never participates
- * in v2 suppression and is never persisted to message metadata.
+ * Injection-block id for the v3 per-turn `<memory_spotlight>` block (the
+ * current window's matched sections). Distinct from {@link MEMORY_V3_BLOCK_ID}:
+ * the spotlight never participates in v2 suppression. Each turn's block stays
+ * on the user message that was sent with it.
  */
 export const MEMORY_V3_SPOTLIGHT_BLOCK_ID = "memory-v3-spotlight" as const;
 
+/**
+ * Message-metadata key for the wrapped `<memory_spotlight>` block persisted
+ * on the user row that received it. `loadFromDb` rehydrates from this key so
+ * historical turns keep the spotlight they were sent with. Kept as a
+ * literal in `messageMetadataSchema` (same pattern as
+ * `memoryV3InjectedBlock`) so the storage schema does not import the
+ * memory feature.
+ */
+export const MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY =
+  "memoryV3SpotlightBlock" as const;
+
 /**
  * A single section of a page: the lead (text before the first `## heading`,
  * ordinal 0) or a heading-delimited block. Over-long sections are split into

package/src/plugins/defaults/turn-context/injectors.ts

@@ -37,6 +37,9 @@ const unifiedTurnContextInjector: Injector = {
       clientOs: ctx.clientOs,
       visibleApp: ctx.visibleApp,
       channelName: ctx.channelName,
+      // The chat and thread this turn arrived through, from its trust snapshot.
+      chatId: ctx.trust.requesterChatId,
+      threadId: ctx.trust.sourceThreadId,
       actorContext: ctx.actorContext,
       configuredUserTimezone: ctx.configuredUserTimezone,
       clientTimezone: ctx.clientTimezone,

package/src/plugins/defaults/turn-context/unified-turn-context.ts

@@ -33,6 +33,19 @@ export interface UnifiedTurnContextOptions {
     pluginName?: string;
   } | null;
   channelName?: string;
+  /**
+   * Channel-native id of the chat this turn arrived through (a Slack `D…` or
+   * `C…` id, a Telegram chat id). Rendered as the `chat_id:` line for channel
+   * turns only, so a request that needs the chat's own history starts from
+   * the id the turn already carries instead of discovering it.
+   */
+  chatId?: string | null;
+  /**
+   * Channel-native thread id of the message that started this turn, when it
+   * arrived in a thread (a Slack `thread_ts`). Rendered as the `thread_id:`
+   * line beside `chat_id:`; absent for an un-threaded turn.
+   */
+  threadId?: string | null;
   actorContext?: InboundActorContext | null;
   configuredUserTimezone?: string | null;
   clientTimezone?: string | null;
@@ -130,6 +143,17 @@ export function buildUnifiedTurnContextBlock(
     );
   }
 
+  // Where the turn is: the chat, and the thread within it when there is one.
+  // Channel turns only; an app turn has no external chat.
+  if (options.channelName && options.channelName !== "vellum") {
+    if (options.chatId) {
+      lines.push(`chat_id: ${sanitizeInlineContextValue(options.chatId)}`);
+    }
+    if (options.threadId) {
+      lines.push(`thread_id: ${sanitizeInlineContextValue(options.threadId)}`);
+    }
+  }
+
   // Actor identity and trust fields — only for non-guardian turns.
   if (options.actorContext) {
     const ctx = options.actorContext;

package/src/plugins/mcp-servers.ts

@@ -93,13 +93,25 @@ const PluginStdioServerSchema = z.object({
   cwd: z.string().optional(),
 });
 
+/**
+ * Remote MCP entry. Agent Plugins 1.0.0 requires `type` and names no
+ * default. MCP's current remote transport is Streamable HTTP, so this
+ * host fills omitted `type` and the Claude-style `http` alias as
+ * `streamable-http`. `sse` stays explicit.
+ */
 const PluginHttpServerSchema = z.object({
-  type: z.enum(["streamable-http", "sse"]),
+  type: z
+    .union([
+      z.literal("streamable-http"),
+      z.literal("sse"),
+      z.literal("http").transform(() => "streamable-http" as const),
+    ])
+    .default("streamable-http"),
   url: z.string().min(1),
   headers: z.record(z.string(), z.string()).optional(),
 });
 
-const PluginMcpServerSchema = z.discriminatedUnion("type", [
+const PluginMcpServerSchema = z.union([
   PluginStdioServerSchema,
   PluginHttpServerSchema,
 ]);