@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/config/schemas/memory-v3.ts

@@ -1,33 +1,5 @@
 import { z } from "zod";
 
-/**
- * Memory v3 (section-grain lane retrieval) working-set configuration.
- *
- * The working set is the per-conversation set of concept pages carried
- * forward across turns. Eviction keeps it bounded: pages unseen for longer
- * than `evictWindow` turns are dropped, and the set is capped at `maxPages`.
- */
-export const MemoryV3WorkingSetSchema = z
-  .object({
-    maxPages: z
-      .number({ error: "memory.v3.workingSet.maxPages must be a number" })
-      .int("memory.v3.workingSet.maxPages must be an integer")
-      .positive("memory.v3.workingSet.maxPages must be a positive integer")
-      .default(150)
-      .describe(
-        "Upper bound on the number of pages retained in the working set. Once exceeded, the least-salient non-pinned pages are evicted until the set fits.",
-      ),
-    evictWindow: z
-      .number({ error: "memory.v3.workingSet.evictWindow must be a number" })
-      .int("memory.v3.workingSet.evictWindow must be an integer")
-      .positive("memory.v3.workingSet.evictWindow must be a positive integer")
-      .default(5)
-      .describe(
-        "Number of turns a non-pinned page may go unseen before it is evicted from the working set.",
-      ),
-  })
-  .describe("Memory v3 working-set retention/eviction tuning.");
-
 /**
  * Edge-lane tuning for the link-graph expansion that folds a turn's lexical and
  * dense seeds outward to their first-class neighbours.
@@ -67,10 +39,111 @@ export const MemoryV3EdgeSchema = z
   })
   .describe("Memory v3 edge-lane (link-graph expansion) tuning.");
 
+/**
+ * Hot-set lane tuning: the top-K pages by exponentially-decayed selection
+ * frequency (frecency) folded into the candidate pool as a stable lane.
+ */
+export const MemoryV3HotSetSchema = z
+  .object({
+    k: z
+      .number({ error: "memory.v3.hotSet.k must be a number" })
+      .int("memory.v3.hotSet.k must be an integer")
+      .positive("memory.v3.hotSet.k must be a positive integer")
+      .default(40)
+      .describe(
+        "Number of top frecency-scored pages included in the hot-set lane.",
+      ),
+    halfLifeDays: z
+      .number({ error: "memory.v3.hotSet.halfLifeDays must be a number" })
+      .positive("memory.v3.hotSet.halfLifeDays must be a positive number")
+      .default(14)
+      .describe(
+        "Frecency decay half-life in days: a selection this old contributes half the weight of one made now.",
+      ),
+  })
+  .describe("Memory v3 hot-set lane (decayed selection frequency) tuning.");
+
+/**
+ * Ephemeral section-spotlight tuning: how many of the current turn's selected
+ * finder hits render their matched section into the `<memory_spotlight>`
+ * block, and how many previous turns' spotlight entries are carried along
+ * before they age out. The block is strip-and-replaced every turn, so its
+ * size is bounded by `n × (windowTurns + 1)` entries.
+ */
+export const MemoryV3SpotlightSchema = z
+  .object({
+    n: z
+      .number({ error: "memory.v3.spotlight.n must be a number" })
+      .int("memory.v3.spotlight.n must be an integer")
+      .positive("memory.v3.spotlight.n must be a positive integer")
+      .default(6)
+      .describe(
+        "Number of the current turn's selected finder hits whose matched sections render into the spotlight block.",
+      ),
+    windowTurns: z
+      .number({ error: "memory.v3.spotlight.windowTurns must be a number" })
+      .int("memory.v3.spotlight.windowTurns must be an integer")
+      .nonnegative(
+        "memory.v3.spotlight.windowTurns must be a non-negative integer",
+      )
+      .default(2)
+      .describe(
+        "Number of previous turns whose spotlight entries are carried into the current block before aging out (0 = current turn only).",
+      ),
+  })
+  .describe("Memory v3 ephemeral section-spotlight tuning.");
+
+/**
+ * Prune-valve bounds on the resident (non-pruned) frozen-card footprint.
+ *
+ * Frozen cards accumulate in history with no per-turn bound, so the valve is
+ * the structural backstop: once resident card bytes exceed
+ * `maxResidentBytes`, the least-recently-selected non-core/non-hot cards are
+ * pruned until the footprint is back at `targetResidentBytes`.
+ *
+ * Defaults rationale: production v2 ran 303KB of accumulated memory unpruned
+ * on the widest observed conversation — 384KB max / 256KB target make the
+ * valve insurance for growth beyond that, not routine behavior.
+ */
+export const MemoryV3PruneSchema = z
+  .object({
+    maxResidentBytes: z
+      .number({ error: "memory.v3.prune.maxResidentBytes must be a number" })
+      .int("memory.v3.prune.maxResidentBytes must be an integer")
+      .positive("memory.v3.prune.maxResidentBytes must be a positive integer")
+      .default(393216 /* 384KB */)
+      .describe(
+        "Resident (non-pruned) card bytes above which the prune valve fires.",
+      ),
+    targetResidentBytes: z
+      .number({
+        error: "memory.v3.prune.targetResidentBytes must be a number",
+      })
+      .int("memory.v3.prune.targetResidentBytes must be an integer")
+      .positive(
+        "memory.v3.prune.targetResidentBytes must be a positive integer",
+      )
+      .default(262144 /* 256KB */)
+      .describe(
+        "Resident card bytes a fired prune reduces the footprint to (must be below maxResidentBytes).",
+      ),
+  })
+  .refine((value) => value.targetResidentBytes < value.maxResidentBytes, {
+    error:
+      "memory.v3.prune.targetResidentBytes must be less than memory.v3.prune.maxResidentBytes",
+  })
+  .describe("Memory v3 prune-valve (resident card footprint) bounds.");
+
+// NOTE: a retired `workingSet` sub-config (maxPages/evictWindow for the old
+// per-turn carry set) used to live here. Existing user config files may still
+// contain the key; zod default unknown-key stripping accepts and ignores it,
+// so legacy configs keep parsing. Do not make this object `.strict()`.
 export const MemoryV3ConfigSchema = z
   .object({
-    workingSet: MemoryV3WorkingSetSchema.default(
-      MemoryV3WorkingSetSchema.parse({}),
+    prune: MemoryV3PruneSchema.default(MemoryV3PruneSchema.parse({})),
+    hotSet: MemoryV3HotSetSchema.default(MemoryV3HotSetSchema.parse({})),
+    spotlight: MemoryV3SpotlightSchema.default(
+      MemoryV3SpotlightSchema.parse({}),
     ),
     needleK: z
       .number({ error: "memory.v3.needleK must be a number" })
@@ -90,8 +163,6 @@ export const MemoryV3ConfigSchema = z
       ),
     edge: MemoryV3EdgeSchema.default(MemoryV3EdgeSchema.parse({})),
   })
-  .describe(
-    "Memory v3 — section-grain lane retrieval with a carry-forward working set",
-  );
+  .describe("Memory v3 — section-grain lane retrieval");
 
 export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/seed-inference-profiles.ts

@@ -229,7 +229,7 @@ export function seedInferenceProfiles(
   //    profiles without duplicating; we have to honor those edits across
   //    reseeds or they'd silently revert on every boot. Carry by
   //    key-presence rather than truthiness so an explicit `null` (user
-  //    cleared the label) survives too. Codex P1 finding on PR #30362.
+  //    cleared the label) survives too.
   //
   //    BYOK seed defaults (off-platform only):
   //      • label: " (Managed)" suffix disambiguates managed profile labels

package/src/config/skills.ts

@@ -1,4 +1,5 @@
 import {
+  type Dirent,
   existsSync,
   lstatSync,
   readdirSync,
@@ -17,18 +18,16 @@ import {
 
 import { z } from "zod";
 
-import {
-  getPluginContributedSkillDefinition,
-  getPluginContributedSkillSummaries,
-} from "../plugins/plugin-skill-contributions.js";
 import { parseFrontmatterFields } from "../skills/frontmatter.js";
 import type { InlineCommandExpansion } from "../skills/inline-command-expansions.js";
 import { parseInlineCommandExpansions } from "../skills/inline-command-expansions.js";
 import { parseToolManifestFile } from "../skills/tool-manifest.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
+import type { OwnerInfo } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import {
   getWorkspaceDirDisplay,
+  getWorkspacePluginsDir,
   getWorkspaceSkillsDir,
 } from "../util/platform.js";
 import { stripCommentLines } from "../util/strip-comment-lines.js";
@@ -47,6 +46,7 @@ const VellumMetadataSchema = z
     "feature-flag": z.string().optional(),
     "activation-hints": z.array(z.string()).optional(),
     "avoid-when": z.array(z.string()).optional(),
+    category: z.string().optional(),
   })
   .passthrough();
 
@@ -66,9 +66,9 @@ const SkillMetadataSchema = z
  * - `workspace`: user-authored skill living in a conversation's working dir.
  * - `extra`: third-party directory roots passed via `loadSkillCatalog`'s
  *   `extraDirs` argument (primarily for tests).
- * - `plugin`: contributed at runtime by a loaded plugin via
- *   `PluginSkillRegistration`. Body is held in-memory by
- *   `plugins/plugin-skill-contributions.ts`, not on disk.
+ * - `plugin`: shipped on disk inside an installed plugin at
+ *   `<workspaceDir>/plugins/<name>/skills/<id>/SKILL.md`, attributed back to
+ *   the owning plugin via its `owner` descriptor.
  */
 export type SkillSource =
   | "bundled"
@@ -90,6 +90,13 @@ export interface SkillSummary {
   icon?: string;
   emoji?: string;
   source: SkillSource;
+  /**
+   * Ownership descriptor identifying the extension that ships this skill,
+   * reusing the same {@link OwnerInfo} model the tool registry uses. Set only
+   * for `source: "plugin"` skills — `{ kind: "plugin", id: <plugin dir name> }`
+   * — attributing them to the installed plugin under `<workspaceDir>/plugins/`.
+   */
+  owner?: OwnerInfo;
   /** Parsed tool manifest metadata, if the skill has a valid TOOLS.json. */
   toolManifest?: SkillToolManifestMeta;
   /** IDs of child skills that this skill includes (metadata-only, not auto-activated). */
@@ -100,6 +107,8 @@ export interface SkillSummary {
   activationHints?: string[];
   /** Conditions under which this skill should NOT be loaded. */
   avoidWhen?: string[];
+  /** Category slug declared in frontmatter, used as a fallback when the skill is not in the Vellum catalog. */
+  category?: string;
   /** Parsed inline command expansion descriptors (`!\`command\``) found in the skill body. */
   inlineCommandExpansions?: InlineCommandExpansion[];
 }
@@ -217,6 +226,7 @@ interface ParsedFrontmatter {
   featureFlag?: string;
   activationHints?: string[];
   avoidWhen?: string[];
+  category?: string;
   inlineCommandExpansions?: InlineCommandExpansion[];
 }
 
@@ -327,6 +337,11 @@ function parseFrontmatter(
   const activationHints = normalizeStringArray(vellum?.["activation-hints"]);
   const avoidWhen = normalizeStringArray(vellum?.["avoid-when"]);
 
+  const category =
+    typeof vellum?.category === "string" && vellum.category.trim().length > 0
+      ? vellum.category.trim()
+      : undefined;
+
   const strippedBody = stripCommentLines(body);
 
   // Parse inline command expansions from the body (after frontmatter/comment stripping)
@@ -350,6 +365,7 @@ function parseFrontmatter(
     featureFlag,
     activationHints,
     avoidWhen,
+    category,
     inlineCommandExpansions,
   };
 }
@@ -506,6 +522,7 @@ function readSkillFromDirectory(
       featureFlag: parsed.featureFlag,
       activationHints: parsed.activationHints,
       avoidWhen: parsed.avoidWhen,
+      category: parsed.category,
       inlineCommandExpansions: parsed.inlineCommandExpansions,
     };
   } catch (err) {
@@ -558,6 +575,7 @@ function readBundledSkillFromDirectory(
       featureFlag: parsed.featureFlag,
       activationHints: parsed.activationHints,
       avoidWhen: parsed.avoidWhen,
+      category: parsed.category,
       inlineCommandExpansions: parsed.inlineCommandExpansions,
     };
   } catch (err) {
@@ -618,6 +636,7 @@ function loadBundledSkills(): SkillSummary[] {
       featureFlag: skill.featureFlag,
       activationHints: skill.activationHints,
       avoidWhen: skill.avoidWhen,
+      category: skill.category,
       inlineCommandExpansions: skill.inlineCommandExpansions,
     });
   }
@@ -646,6 +665,82 @@ function discoverSkillDirectories(skillsDir: string): string[] {
   return dirs.sort((a, b) => a.localeCompare(b));
 }
 
+/**
+ * Whether `pluginDir` is a recognized installed plugin: it must carry a
+ * parseable `package.json` whose `name` equals the directory name. This
+ * mirrors the external plugin loader's recognition gate, which skips any
+ * directory whose `manifest.name` does not match its directory name.
+ */
+function isRecognizedPluginDir(pluginDir: string, dirName: string): boolean {
+  const manifestPath = join(pluginDir, "package.json");
+  if (!existsSync(manifestPath)) return false;
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    return (
+      typeof parsed === "object" &&
+      parsed !== null &&
+      "name" in parsed &&
+      (parsed as { name: unknown }).name === dirName
+    );
+  } catch (err) {
+    log.warn(
+      { err, manifestPath },
+      "Skipping plugin dir with unparseable package.json for resident skills",
+    );
+    return false;
+  }
+}
+
+/**
+ * Discover skills shipped on disk inside installed plugins. Each installed
+ * plugin — a directory under `<workspaceDir>/plugins/` recognized by
+ * {@link isRecognizedPluginDir} — may ship skills at `skills/<id>/SKILL.md`.
+ * Returned summaries are attributed to the owning plugin via their `owner`
+ * descriptor (`{ kind: "plugin", id: <plugin dir name> }`).
+ */
+function discoverPluginResidentSkills(): SkillSummary[] {
+  const pluginsDir = getWorkspacePluginsDir();
+  if (!existsSync(pluginsDir)) return [];
+
+  let entries: Dirent[];
+  try {
+    entries = readdirSync(pluginsDir, { withFileTypes: true });
+  } catch (err) {
+    log.warn(
+      { err, pluginsDir },
+      "Failed to read plugins directory for resident skills",
+    );
+    return [];
+  }
+
+  const summaries: SkillSummary[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const pluginDir = join(pluginsDir, entry.name);
+    // Mirror the plugin loader's recognition gate: a directory is a real
+    // installed plugin only if it carries a parseable `package.json` whose
+    // `name` matches the directory. This rejects staging dirs, stray files,
+    // and malformed/mismatched clones (e.g. an un-adapted `caveman-installer`)
+    // that the loader itself would skip, so the catalog never surfaces skills
+    // from a directory the runtime would refuse to load.
+    if (!isRecognizedPluginDir(pluginDir, entry.name)) continue;
+
+    const skillsDir = join(pluginDir, "skills");
+    if (!existsSync(skillsDir)) continue;
+
+    for (const directory of discoverSkillDirectories(skillsDir)) {
+      const skill = readSkillFromDirectory(directory, skillsDir, "plugin");
+      if (!skill) continue;
+      summaries.push({
+        ...skillSummaryFromDefinition(skill, "plugin"),
+        owner: { kind: "plugin", id: entry.name },
+      });
+    }
+  }
+
+  return summaries;
+}
+
 // ─── Catalog loading ─────────────────────────────────────────────────────────
 
 function skillSummaryFromDefinition(
@@ -668,6 +763,7 @@ function skillSummaryFromDefinition(
     featureFlag: skill.featureFlag,
     activationHints: skill.activationHints,
     avoidWhen: skill.avoidWhen,
+    category: skill.category,
     inlineCommandExpansions: skill.inlineCommandExpansions,
   };
 }
@@ -721,6 +817,7 @@ export function loadSkillCatalog(
             featureFlag: parsed.featureFlag,
             activationHints: parsed.activationHints,
             avoidWhen: parsed.avoidWhen,
+            category: parsed.category,
             inlineCommandExpansions: parsed.inlineCommandExpansions,
           });
         } catch (err) {
@@ -754,12 +851,11 @@ export function loadSkillCatalog(
     catalog.push(skill);
   }
 
-  // Load plugin-contributed skills. They sit above bundled/extra but below
-  // managed and workspace so that user-authored filesystem skills can
-  // override a plugin-provided skill by declaring the same id under
-  // `~/.vellum/workspace/skills/`. Registration is owned by the plugin
-  // bootstrap — this call is a pure read against the in-memory registry.
-  const pluginSkills = getPluginContributedSkillSummaries();
+  // Discover skills shipped on disk inside installed plugins. They sit above
+  // bundled/extra but below managed and workspace so a user-authored
+  // filesystem skill can override a plugin-provided skill by declaring the
+  // same id under `$VELLUM_WORKSPACE_DIR/skills/`.
+  const pluginSkills = discoverPluginResidentSkills();
   for (const skill of pluginSkills) {
     if (seenIds.has(skill.id)) {
       const existingIndex = catalog.findIndex((s) => s.id === skill.id);
@@ -769,14 +865,14 @@ export function loadSkillCatalog(
           catalog[existingIndex].source === "extra")
       ) {
         log.info(
-          { id: skill.id, pluginSkill: true },
+          { id: skill.id, pluginName: skill.owner?.id },
           "Plugin skill overrides bundled/extra skill",
         );
         catalog[existingIndex] = skill;
         continue;
       }
       log.warn(
-        { id: skill.id },
+        { id: skill.id, pluginName: skill.owner?.id },
         "Skipping duplicate plugin skill id (already present in catalog)",
       );
       continue;
@@ -857,6 +953,7 @@ export function loadSkillCatalog(
           featureFlag: parsed.featureFlag,
           activationHints: parsed.activationHints,
           avoidWhen: parsed.avoidWhen,
+          category: parsed.category,
           inlineCommandExpansions: parsed.inlineCommandExpansions,
         };
 
@@ -992,41 +1089,13 @@ export function listReferenceFiles(directoryPath: string): string | null {
 }
 
 function loadSkillDefinition(skill: SkillSummary): SkillLookupResult {
-  // Plugin-contributed skills live in-memory, not on disk. The registry
-  // (see `plugins/plugin-skill-contributions.ts`) stores a pre-built
-  // SkillDefinition we can return directly — no file read, no frontmatter
-  // parse. We still run placeholder / feature-gate substitution on the
-  // body so plugin skills behave the same as filesystem skills from the
-  // model's perspective.
-  if (skill.source === "plugin") {
-    const pluginDef = getPluginContributedSkillDefinition(skill.id);
-    if (!pluginDef) {
-      // The skill was in the catalog when the selector ran but has since
-      // been unregistered (plugin hot-reload, shutdown race). Fail loudly
-      // rather than returning a mystery undefined.
-      return {
-        error: `Plugin-contributed skill "${skill.id}" is no longer registered`,
-      };
-    }
-    // Shallow-clone so mutating the returned `body` below does not touch
-    // the registry's stored copy — the registry must stay the source of
-    // truth across repeated `skill_load` calls.
-    const loaded: SkillDefinition = { ...pluginDef };
-    loaded.body = loaded.body.replaceAll("{baseDir}", loaded.directoryPath);
-    loaded.body = loaded.body.replaceAll(
-      "{workspaceDir}",
-      getWorkspaceDirDisplay(),
-    );
-    loaded.body = applyFeatureGatedSections(loaded.body);
-    return { skill: loaded };
-  }
-
   let loaded: SkillDefinition | null;
   if (skill.bundled) {
     loaded = readBundledSkillFromDirectory(skill.directoryPath);
-  } else if (skill.source === "workspace") {
-    // Workspace skills live outside ~/.vellum/workspace/skills, so use their parent
-    // directory as the root to avoid the isOutsideSkillsRoot rejection.
+  } else if (skill.source === "workspace" || skill.source === "plugin") {
+    // Workspace and plugin-resident skills live outside
+    // $VELLUM_WORKSPACE_DIR/skills, so use the skill's parent directory as the
+    // root to avoid the isOutsideSkillsRoot rejection.
     loaded = readSkillFromDirectory(
       skill.directoryPath,
       dirname(skill.directoryPath),
@@ -1042,6 +1111,7 @@ function loadSkillDefinition(skill: SkillSummary): SkillLookupResult {
   if (!loaded) {
     return { error: `Failed to load SKILL.md for "${skill.id}"` };
   }
+  loaded.owner = skill.owner;
   // Replace {baseDir} placeholders with the actual skill directory path
   loaded.body = loaded.body.replaceAll("{baseDir}", loaded.directoryPath);
   // Replace {workspaceDir} placeholders with the runtime workspace display path

package/src/context/compactor.ts

@@ -743,12 +743,19 @@ export async function runAssistantDrivenCompaction(
   let response: ProviderResponse;
   try {
     response = await args.provider.sendMessage(requestMessages, {
+      // Tools are passed so the cached prefix (system prompt + tools +
+      // history) matches the agent's main-turn cache key. Force
+      // `tool_choice: "none"` so the model can only answer with the
+      // `<compaction_result>` text and never burns the turn on a tool call
+      // it cannot complete — an empty text response yields no parseable
+      // summary, stalls compaction, and exhausts the agent loop budget.
       tools: args.tools,
       systemPrompt: args.systemPrompt,
       signal: args.signal,
       config: {
         callSite: COMPACTION_CALL_SITE,
         usageTracking: "manual",
+        tool_choice: { type: "none" },
         ...(args.overrideProfile
           ? { overrideProfile: args.overrideProfile }
           : {}),
@@ -1113,12 +1120,16 @@ export async function runEmergencyCompaction(
   let response: ProviderResponse;
   try {
     response = await args.provider.sendMessage(requestMessages, {
+      // See the assistant-driven path: tools keep the prefix cache warm, but
+      // `tool_choice: "none"` forces a text-only `<compaction_result>` so the
+      // model can't stall compaction by emitting an uncompletable tool call.
       tools: args.tools,
       systemPrompt: args.systemPrompt,
       signal: args.signal,
       config: {
         callSite: COMPACTION_CALL_SITE,
         usageTracking: "manual",
+        tool_choice: { type: "none" },
         ...(args.overrideProfile
           ? { overrideProfile: args.overrideProfile }
           : {}),

package/src/context/strip-injections.ts

@@ -11,6 +11,10 @@
  * loop (which drives the compaction pipeline) and the compactor can call it
  * without reaching up into the daemon orchestrator.
  */
+import {
+  MEMORY_SPOTLIGHT_PREFIX,
+  MEMORY_SPOTLIGHT_SUFFIX,
+} from "../memory/memory-marker.js";
 import type { Message } from "../providers/types.js";
 
 /**
@@ -56,6 +60,34 @@ export function stripUserTextBlocksByPrefix(
     );
 }
 
+/**
+ * Full-wrapper matcher for the memory-v3 ephemeral `<memory_spotlight>` block.
+ * Shared by the per-turn scoped strip ({@link stripSpotlightInjections}) and
+ * the compaction pipeline below so both recognize exactly the same wrapper.
+ */
+const MEMORY_SPOTLIGHT_MATCHER: InjectionMatcher = {
+  prefix: MEMORY_SPOTLIGHT_PREFIX,
+  suffix: MEMORY_SPOTLIGHT_SUFFIX,
+};
+
+/**
+ * Remove memory-v3 `<memory_spotlight>` blocks from every user message — and
+ * ONLY those blocks. The spotlight is ephemeral by contract: runtime assembly
+ * strip-and-replaces it each turn (the previous turn's spotlight is stale),
+ * while the frozen `<memory>` card blocks stay byte-identical in history for
+ * prompt caching. This is deliberately a scoped, single-id strip — the old
+ * whole-layer `stripAllMemoryInjections` replace is gone.
+ */
+export function stripSpotlightInjections(messages: Message[]): Message[] {
+  return stripUserTextBlocksByPrefix(messages, [MEMORY_SPOTLIGHT_MATCHER]);
+}
+
+/** `<NOW.md>` scratchpad prefixes (current tag, pre-line-limit variant, legacy `<now_scratchpad>`) — shared with `stripNowScratchpad` so the two strip paths can't drift. */
+export const NOW_SCRATCHPAD_STRIP_PREFIXES: InjectionMatcher[] = [
+  "<NOW.md Always keep this up to date",
+  "<now_scratchpad>",
+];
+
 /** Matchers stripped by the pipeline (order doesn't matter — single pass). */
 const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
   "<channel_capabilities>",
@@ -85,6 +117,11 @@ const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
   // matches the full-wrapper requirement in `countMemoryPrefixBlocks`.
   { prefix: "<memory>\n", suffix: "\n</memory>" },
   { prefix: "<info>\n", suffix: "\n</info>" },
+  // The memory-v3 ephemeral spotlight block. Normally strip-and-replaced every
+  // turn by `stripSpotlightInjections`, but registered here too so compaction
+  // and overflow recovery remove a stale spotlight along with the rest of the
+  // runtime injections. Full-wrapper shape for the same reason as `<memory>`.
+  MEMORY_SPOTLIGHT_MATCHER,
   "<voice_call_control>",
   "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
   // The `<workspace>` top-level block is stripped so each compaction re-injects
@@ -100,10 +137,7 @@ const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
   "<active_workspace>",
   "<active_dynamic_page>",
   "<non_interactive_context>",
-  // Shared prefix catches both the current NOW.md tag and any pre-line-limit
-  // variant that may linger in in-flight histories during a rolling deploy.
-  "<NOW.md Always keep this up to date",
-  "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
+  ...NOW_SCRATCHPAD_STRIP_PREFIXES,
   "<knowledge_base>",
   "<pkb>", // backward-compat: strip legacy tag from pre-rename history
   "<system_reminder>",

package/src/credential-execution/feature-gates.ts

@@ -28,12 +28,6 @@ export const CES_SECURE_INSTALL_FLAG_KEY = "ces-secure-install" as const;
 /** Gate for credential grant and audit inspection surfaces. */
 export const CES_GRANT_AUDIT_FLAG_KEY = "ces-grant-audit" as const;
 
-/** Gate for routing credential reads/writes through the CES process. */
-const CES_CREDENTIAL_BACKEND_FLAG_KEY = "ces-credential-backend" as const;
-
-/** Gate for managed sidecar transport in containerized environments. */
-export const CES_MANAGED_SIDECAR_FLAG_KEY = "ces-managed-sidecar" as const;
-
 // ---------------------------------------------------------------------------
 // Public API — predicate functions
 // ---------------------------------------------------------------------------
@@ -66,18 +60,3 @@ export function isCesGrantAuditEnabled(config: AssistantConfig): boolean {
   return isAssistantFeatureFlagEnabled(CES_GRANT_AUDIT_FLAG_KEY, config);
 }
 
-/**
- * Whether credential reads and writes should be routed through the CES process.
- */
-export function isCesCredentialBackendEnabled(
-  config: AssistantConfig,
-): boolean {
-  return isAssistantFeatureFlagEnabled(CES_CREDENTIAL_BACKEND_FLAG_KEY, config);
-}
-
-/**
- * Whether managed sidecar transport should be used for CES communication.
- */
-export function isCesManagedSidecarEnabled(config: AssistantConfig): boolean {
-  return isAssistantFeatureFlagEnabled(CES_MANAGED_SIDECAR_FLAG_KEY, config);
-}

package/src/credential-execution/startup-timeout.ts

@@ -11,10 +11,8 @@ export async function awaitCesClientWithTimeout(
   clientPromise: Promise<CesClient | undefined>,
   options: AwaitCesClientWithTimeoutOptions = {},
 ): Promise<CesClient | undefined> {
-  const {
-    timeoutMs = DEFAULT_CES_STARTUP_TIMEOUT_MS,
-    onTimeout = () => {},
-  } = options;
+  const { timeoutMs = DEFAULT_CES_STARTUP_TIMEOUT_MS, onTimeout = () => {} } =
+    options;
 
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
 
@@ -34,3 +32,33 @@ export async function awaitCesClientWithTimeout(
     }
   }
 }
+
+export interface CesClientResolver {
+  getCesClient: () => CesClient | undefined;
+  setCesClient: (client: CesClient) => void;
+}
+
+/**
+ * Inject the CES client into the credential resolver once the startup
+ * handshake resolves.
+ *
+ * {@link awaitCesClientWithTimeout} only gates provider initialization: when
+ * the handshake loses the race it returns before the client exists, so the
+ * caller cannot inject it synchronously. This bridges that gap by injecting
+ * the client whenever the handshake eventually completes. The resolver is left
+ * untouched if it already holds a client (e.g. one installed by a reconnection
+ * while the late handshake was still in flight) so the older startup client
+ * never clobbers a newer one, and a failed or aborted handshake is a no-op.
+ */
+export function injectCesClientWhenReady(
+  clientPromise: Promise<CesClient | undefined>,
+  resolver: CesClientResolver,
+): void {
+  void clientPromise
+    .then((client) => {
+      if (client && resolver.getCesClient() === undefined) {
+        resolver.setCesClient(client);
+      }
+    })
+    .catch(() => undefined);
+}