@vellumai/assistant 0.10.4-dev.202607021837.b0213d4 → 0.10.4-dev.202607021852.8dcc2d9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607021837.b0213d4",
+  "version": "0.10.4-dev.202607021852.8dcc2d9",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -144,6 +144,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../skills/catalog-cache.js",
     "../../../../skills/install-meta.js",
     "../../../../skills/skill-memory.js",
+    "../../../../telemetry/watchdog-events-store.js",
     "../../../../tools/skills/delete-managed.js",
     "../../../../util/abort-reasons.js",
     "../../../../util/errors.js",

package/src/config/feature-flag-registry.json

@@ -359,8 +359,8 @@
       "scope": "assistant",
       "key": "memory-v3-injection-gate",
       "label": "Memory v3 injection gate",
-      "description": "Per-turn injection gate for memory v3: after the BM25F needle + dense cosine finder lanes run, skip the selectPool LLM call (inject nothing) when finder-lane scores fall below the configured thresholds (memory.v3.gate). Default off.",
-      "defaultEnabled": false
+      "description": "Per-turn injection gate for memory v3: after the BM25F needle + dense cosine finder lanes run, skip the selectPool LLM call (inject nothing) when finder-lane scores fall below the configured thresholds (memory.v3.gate). Default on (flipped remotely July 2026); this registry value is the fallback when no platform snapshot is available.",
+      "defaultEnabled": true
     },
     {
       "id": "self-intro-greeting",

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

@@ -79,8 +79,37 @@ mock.module("../dense.js", () => ({
   },
 }));
 
-const { orchestrate, DEFAULT_NEEDLE_K, DEFAULT_DENSE_K } =
-  await import("../orchestrate.js");
+// The watchdog telemetry store is stubbed with the same active-flag delegation
+// as the dense lane: gate tests capture the per-run gate telemetry; any other
+// test file sharing the process falls through to the real store. Spread the
+// real module so the query/type exports stay present.
+const realWatchdogStore = {
+  ...(await import("../../../../../telemetry/watchdog-events-store.js")),
+};
+let watchdogMockActive = false;
+let recordedGateEvents: Array<{
+  checkName: string;
+  value?: number | null;
+  detail?: Record<string, unknown> | null;
+}> = [];
+mock.module("../../../../../telemetry/watchdog-events-store.js", () => ({
+  ...realWatchdogStore,
+  recordWatchdogEvent: (
+    record: Parameters<typeof realWatchdogStore.recordWatchdogEvent>[0],
+  ) => {
+    if (!watchdogMockActive) {
+      return realWatchdogStore.recordWatchdogEvent(record);
+    }
+    recordedGateEvents.push(record);
+  },
+}));
+
+const {
+  orchestrate,
+  DEFAULT_NEEDLE_K,
+  DEFAULT_DENSE_K,
+  MEMORY_V3_INJECTION_GATE_CHECK_NAME,
+} = await import("../orchestrate.js");
 
 // ---------------------------------------------------------------------------
 // Fixtures: a tiny corpus of pages with bodies + `links:` frontmatter.
@@ -261,9 +290,11 @@ function selectProvider(keep: Slug[], pin: Slug[] = []): Provider {
 
 beforeEach(() => {
   denseMockActive = true;
+  watchdogMockActive = true;
   providerStub = null;
   denseHits = [];
   denseCalls = [];
+  recordedGateEvents = [];
   lastPool = [];
   lastPoolLines = [];
   lastPrefixBlock = null;
@@ -272,6 +303,7 @@ beforeEach(() => {
 
 afterAll(() => {
   denseMockActive = false;
+  watchdogMockActive = false;
 });
 
 // ---------------------------------------------------------------------------
@@ -1199,4 +1231,84 @@ describe("orchestrate — injection gate", () => {
     expect(selectCalls).toBe(1);
     expect(result.selections.map((s) => s.slug)).toContain("topic-a");
   });
+
+  test("a scored gate run records ONE telemetry event carrying the decision", async () => {
+    const lanes = await buildLanes();
+    // Dense top-1 (0.9) clears denseThreshold (0.52) → dense_pass.
+    denseHits = [{ article: "topic-b", section: 0, score: 0.9 }];
+    providerStub = selectProvider(["topic-a"]);
+
+    await orchestrate(
+      makeTurn(1, "apple"),
+      depsOf(lanes, { denseK: 100, gateConfig: gateConfigOf() }),
+    );
+
+    expect(recordedGateEvents).toHaveLength(1);
+    const event = recordedGateEvents[0]!;
+    expect(event.checkName).toBe(MEMORY_V3_INJECTION_GATE_CHECK_NAME);
+    expect(event.value).toBe(1);
+    expect(event.detail).toMatchObject({
+      pass: true,
+      reason: "dense_pass",
+      top_dense_score: 0.9,
+    });
+  });
+
+  test("a closed gate records pass:false with the failure reason", async () => {
+    const lanes = await buildLanes();
+    // No needle-term overlap and sub-threshold dense → fail_no_signal.
+    denseHits = [{ article: "topic-b", section: 0, score: 0.1 }];
+    providerStub = selectProvider([]);
+
+    await orchestrate(
+      makeTurn(1, "zzzz nomatch"),
+      depsOf(lanes, { denseK: 100, gateConfig: gateConfigOf() }),
+    );
+
+    expect(recordedGateEvents).toHaveLength(1);
+    expect(recordedGateEvents[0]!.detail).toMatchObject({
+      pass: false,
+      reason: "fail_no_signal",
+    });
+  });
+
+  test("the dense-unavailable pass-open records reason dense_unavailable", async () => {
+    const lanes = await buildLanes();
+    // denseK: 0 → no live dense hits → the gate passes open without scoring.
+    const needle = {
+      query: () => [],
+      queryScored: () => [{ article: "topic-a", section: 0, score: 0.1 }],
+      bestSection: () => -1,
+      idf: () => 0,
+    };
+    providerStub = selectProvider(["topic-a"]);
+
+    await orchestrate(
+      makeTurn(1, "apple"),
+      depsOf(lanes, { needle, denseK: 0, gateConfig: gateConfigOf() }),
+    );
+
+    expect(recordedGateEvents).toHaveLength(1);
+    expect(recordedGateEvents[0]!.detail).toMatchObject({
+      pass: true,
+      reason: "dense_unavailable",
+    });
+  });
+
+  test("no gate telemetry when the gate is disabled or omitted", async () => {
+    const lanes = await buildLanes();
+    denseHits = [{ article: "topic-b", section: 0, score: 0.1 }];
+    providerStub = selectProvider(["topic-a"]);
+
+    await orchestrate(
+      makeTurn(1, "apple"),
+      depsOf(lanes, {
+        denseK: 100,
+        gateConfig: gateConfigOf({ enabled: false }),
+      }),
+    );
+    await orchestrate(makeTurn(2, "apple"), depsOf(lanes));
+
+    expect(recordedGateEvents).toEqual([]);
+  });
 });

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

@@ -55,6 +55,7 @@
  */
 
 import type { AssistantConfig } from "../../../../config/schema.js";
+import { recordWatchdogEvent } from "../../../../telemetry/watchdog-events-store.js";
 import { getLogger } from "../../../../util/logger.js";
 import { denseLaneScored } from "./dense.js";
 import type { EdgeGraph } from "./edge.js";
@@ -82,6 +83,28 @@ import type {
 // logger names the per-turn INJECTION gate wired in below.
 const log = getLogger("memory-v3-injection-gate");
 
+/** `check_name` of the `watchdog` telemetry event recorded once per
+ *  injection-gate run. The platform's memory admin analytics count and filter
+ *  on this exact string — keep it stable. */
+export const MEMORY_V3_INJECTION_GATE_CHECK_NAME = "memory_v3_injection_gate";
+
+/** Record one injection-gate run to usage telemetry. `detail` keys are the
+ *  platform-side contract (snake_case, scores and reason codes only — never
+ *  conversation content). Never throws: the gate is pass-open by design, and a
+ *  telemetry failure must not cost the turn its memory either. */
+function recordGateRun(detail: Record<string, unknown>): void {
+  try {
+    recordWatchdogEvent({
+      checkName: MEMORY_V3_INJECTION_GATE_CHECK_NAME,
+      value: 1,
+      detail,
+    });
+  } catch {
+    // recordWatchdogEvent already no-ops on opt-out and a missing telemetry
+    // DB; anything past that is not worth failing the turn over.
+  }
+}
+
 /** Default number of BM25 needle articles to fold into the pool. */
 export const DEFAULT_NEEDLE_K = 12;
 /** Default number of dense-lane articles to fold into the pool. */
@@ -429,6 +452,7 @@ export async function orchestrate(
         },
         "memory-v3 injection gate: dense lane unavailable, passing open",
       );
+      recordGateRun({ pass: true, reason: "dense_unavailable" });
     } else {
       let gate: V3GateResult | null = null;
       try {
@@ -445,6 +469,7 @@ export async function orchestrate(
           },
           "memory-v3 injection gate threw; passing open (proceeding with selection)",
         );
+        recordGateRun({ pass: true, reason: "gate_error" });
       }
       if (gate) {
         log.info(
@@ -455,6 +480,13 @@ export async function orchestrate(
           },
           "memory-v3 injection gate decision",
         );
+        recordGateRun({
+          pass: gate.pass,
+          reason: gate.reason,
+          top_dense_score: gate.topDenseScore,
+          top_norm_sparse_score: gate.topNormSparseScore,
+          checked_articles: gate.checkedArticles,
+        });
         if (!gate.pass) {
           // A closed gate produces no finder lane and no matched sections; only
           // the `selections` differ between bypass (stable prefix) and hard-skip.