@vellumai/assistant 0.7.2 → 0.7.3

package/src/ipc/__tests__/clients-list-ipc.test.ts

@@ -0,0 +1,169 @@
+/**
+ * End-to-end test for `assistant clients list` over IPC.
+ *
+ * Regression test for the gap where the same-user filter on
+ * `GET /v1/clients` (which reads `headers["x-vellum-actor-principal-id"]`)
+ * silently returned an empty list over IPC because the IPC adapter did
+ * not inject the synthetic actor-principal header that the HTTP adapter
+ * populates from the verified `AuthContext`.
+ *
+ * Asserts that in non-dev-bypass mode (`isHttpAuthDisabled() === false`),
+ * the CLI sees same-user clients via the IPC path because the IPC server
+ * fills in the header from the local guardian principal.
+ */
+
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+import { runAssistantCommandFull } from "../../cli/__tests__/run-assistant-command.js";
+import { AssistantIpcServer } from "../assistant-server.js";
+
+// ── Module mocks (must be set up before importing the route) ──────────────
+
+let fakeHttpAuthDisabled = false;
+let fakeLocalPrincipalId: string | undefined = "guardian-local";
+
+mock.module("../../config/env.js", () => ({
+  isHttpAuthDisabled: () => fakeHttpAuthDisabled,
+  hasUngatedHttpAuthDisabled: () => false,
+}));
+
+mock.module("../../runtime/local-actor-identity.js", () => ({
+  findLocalGuardianPrincipalId: () => fakeLocalPrincipalId,
+}));
+
+// ── Real imports (after mocks) ────────────────────────────────────────────
+
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
+
+// ── Fixtures ──────────────────────────────────────────────────────────────
+
+let server: AssistantIpcServer | null = null;
+
+function registerClient(args: {
+  clientId: string;
+  actorPrincipalId?: string;
+}): void {
+  assistantEventHub.subscribe({
+    type: "client",
+    clientId: args.clientId,
+    interfaceId: "macos",
+    capabilities: ["host_bash", "host_file", "host_cu"],
+    actorPrincipalId: args.actorPrincipalId,
+    callback: () => {},
+  });
+}
+
+function clearHub(): void {
+  const ids = assistantEventHub.listClients().map((c) => c.clientId);
+  for (const id of ids) {
+    assistantEventHub.disposeClient(id);
+  }
+}
+
+async function startServer(): Promise<void> {
+  server = new AssistantIpcServer();
+  await server.start();
+  // Allow the listener to be ready before the CLI tries to connect.
+  await new Promise((resolve) => setTimeout(resolve, 50));
+}
+
+beforeEach(() => {
+  fakeHttpAuthDisabled = false;
+  fakeLocalPrincipalId = "guardian-local";
+  clearHub();
+});
+
+afterEach(() => {
+  server?.stop();
+  server = null;
+});
+
+afterAll(() => {
+  mock.restore();
+});
+
+// ── Tests ────────────────────────────────────────────────────────────────
+
+describe("assistant clients list over IPC — same-user filter", () => {
+  test("returns same-user clients in non-dev-bypass mode", async () => {
+    registerClient({
+      clientId: "client-self-1",
+      actorPrincipalId: "guardian-local",
+    });
+    registerClient({
+      clientId: "client-self-2",
+      actorPrincipalId: "guardian-local",
+    });
+    registerClient({
+      clientId: "client-other",
+      actorPrincipalId: "other-user",
+    });
+
+    await startServer();
+
+    const { stdout } = await runAssistantCommandFull(
+      "clients",
+      "list",
+      "--json",
+    );
+
+    const parsed = JSON.parse(stdout.trim()) as {
+      clients: Array<{ clientId: string }>;
+    };
+    const ids = parsed.clients.map((c) => c.clientId).sort();
+    expect(ids).toEqual(["client-self-1", "client-self-2"]);
+  });
+
+  test("returns empty when no local guardian principal is bound (fail-closed)", async () => {
+    fakeLocalPrincipalId = undefined;
+    registerClient({
+      clientId: "client-self",
+      actorPrincipalId: "guardian-local",
+    });
+
+    await startServer();
+
+    const { stdout } = await runAssistantCommandFull(
+      "clients",
+      "list",
+      "--json",
+    );
+    const parsed = JSON.parse(stdout.trim()) as {
+      clients: Array<{ clientId: string }>;
+    };
+    expect(parsed.clients).toEqual([]);
+  });
+
+  test("dev-bypass mode returns all clients regardless of principal", async () => {
+    fakeHttpAuthDisabled = true;
+    registerClient({
+      clientId: "client-self",
+      actorPrincipalId: "guardian-local",
+    });
+    registerClient({
+      clientId: "client-other",
+      actorPrincipalId: "other-user",
+    });
+
+    await startServer();
+
+    const { stdout } = await runAssistantCommandFull(
+      "clients",
+      "list",
+      "--json",
+    );
+    const parsed = JSON.parse(stdout.trim()) as {
+      clients: Array<{ clientId: string }>;
+    };
+    const ids = parsed.clients.map((c) => c.clientId).sort();
+    expect(ids).toEqual(["client-other", "client-self"]);
+  });
+});

package/src/ipc/assistant-server.ts

@@ -32,9 +32,13 @@ import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { createServer, type Server, type Socket } from "node:net";
 import { dirname } from "node:path";
 
+import { findLocalGuardianPrincipalId } from "../runtime/local-actor-identity.js";
 import { RouteError } from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/index.js";
-import type { RouteDefinition } from "../runtime/routes/types.js";
+import type {
+  RouteDefinition,
+  RouteHandlerArgs,
+} from "../runtime/routes/types.js";
 import { getLogger } from "../util/logger.js";
 import {
   type IpcEnvelope,
@@ -256,7 +260,8 @@ export class AssistantIpcServer {
     void binary;
 
     try {
-      const result = handler(req.params ?? {});
+      const handlerArgs = injectLocalActorHeader(req.params);
+      const result = handler(handlerArgs);
 
       if (result instanceof Promise) {
         result
@@ -454,3 +459,52 @@ export class AssistantIpcServer {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+
+/**
+ * Inject a synthetic `x-vellum-actor-principal-id` header from the local
+ * guardian principal when the caller hasn't already provided one.
+ *
+ * Local IPC is intra-process and owned by the same user as the daemon, so
+ * routes that consume `headers["x-vellum-actor-principal-id"]` (e.g. the
+ * same-user filter on `GET /v1/clients`) need an actor identity to function
+ * over IPC. The HTTP adapter does this from the verified `AuthContext`
+ * (`http-adapter.ts`); this helper mirrors that convention for IPC.
+ *
+ * Existing headers from the caller (e.g. the gateway's IPC runtime proxy,
+ * which forwards real `x-vellum-*` headers from the authenticated HTTP
+ * request) are preserved — we only fill in the gap for direct CLI/local
+ * IPC callers.
+ */
+function injectLocalActorHeader(
+  params: Record<string, unknown> | undefined,
+): RouteHandlerArgs {
+  const args = (params ?? {}) as RouteHandlerArgs;
+  const existingHeaders = args.headers;
+  if (existingHeaders?.["x-vellum-actor-principal-id"]) {
+    return args;
+  }
+
+  // Defensive: the guardian lookup queries the contacts table, which may
+  // not yet exist on a very early boot path or in test fixtures that don't
+  // initialize the DB. A failure here must not block IPC dispatch — routes
+  // that require the header will fail-closed on their own.
+  let localActor: string | undefined;
+  try {
+    localActor = findLocalGuardianPrincipalId();
+  } catch (err) {
+    log.debug(
+      { err },
+      "failed to resolve local actor principal for IPC header injection",
+    );
+    return args;
+  }
+  if (!localActor) return args;
+
+  return {
+    ...args,
+    headers: {
+      ...existingHeaders,
+      "x-vellum-actor-principal-id": localActor,
+    },
+  };
+}

package/src/ipc/gateway-client.ts

@@ -38,9 +38,10 @@ const log = getLogger("gateway-ipc-client");
 export async function ipcCall(
   method: string,
   params?: Record<string, unknown>,
+  timeoutMs?: number,
 ): Promise<unknown> {
   const socketPath = getGatewaySocketPath();
-  return packageIpcCall(socketPath, method, params, log);
+  return packageIpcCall(socketPath, method, params, log, timeoutMs);
 }
 
 // ---------------------------------------------------------------------------
@@ -90,9 +91,15 @@ export function resetPersistentClient(): void {
 /**
  * Fetch all merged feature flags from the gateway via IPC.
  * Returns an empty record on any failure.
+ *
+ * @param timeoutMs - Optional timeout override forwarded to the IPC
+ *   transport. Pass a small value (e.g. 200) for CLI startup paths where
+ *   a slow/absent gateway should fail fast.
  */
-export async function ipcGetFeatureFlags(): Promise<Record<string, boolean>> {
-  const result = await ipcCall("get_feature_flags");
+export async function ipcGetFeatureFlags(
+  timeoutMs?: number,
+): Promise<Record<string, boolean>> {
+  const result = await ipcCall("get_feature_flags", undefined, timeoutMs);
   if (result && typeof result === "object" && !Array.isArray(result)) {
     const filtered: Record<string, boolean> = {};
     for (const [k, v] of Object.entries(result as Record<string, unknown>)) {
@@ -103,6 +110,33 @@ export async function ipcGetFeatureFlags(): Promise<Record<string, boolean>> {
   return {};
 }
 
+// ---------------------------------------------------------------------------
+// Velay tunnel status
+// ---------------------------------------------------------------------------
+
+export interface VelayTunnelStatus {
+  connected: boolean;
+  publicUrl: string | null;
+}
+
+/**
+ * Fetch the current Velay tunnel status from the gateway via IPC.
+ * Returns `null` when the gateway is unreachable or returns an unexpected
+ * response — callers should treat `null` as "gateway not running".
+ */
+export async function ipcGetVelayStatus(): Promise<VelayTunnelStatus | null> {
+  const result = await ipcCall("get_velay_status");
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    return null;
+  }
+  const obj = result as Record<string, unknown>;
+  if (typeof obj.connected !== "boolean") return null;
+  return {
+    connected: obj.connected,
+    publicUrl: typeof obj.publicUrl === "string" ? obj.publicUrl : null,
+  };
+}
+
 /**
  * Classify risk for a tool invocation via the gateway's persistent IPC
  * connection.

package/src/live-voice/live-voice-archive.ts

@@ -17,7 +17,7 @@ const LIVE_VOICE_AUDIO_SOURCE = "live-voice";
 
 export type LiveVoiceAudioArchiveRole = "user" | "assistant";
 
-export type LiveVoiceAudioSource =
+type LiveVoiceAudioSource =
   | {
       type: "base64";
       dataBase64: string;
@@ -28,7 +28,7 @@ export type LiveVoiceAudioSource =
       sizeBytes?: number;
     };
 
-export interface ArchiveLiveVoiceAudioInput {
+interface ArchiveLiveVoiceAudioInput {
   messageId: string;
   sessionId: string;
   turnId: string;
@@ -55,7 +55,7 @@ export interface LiveVoiceAudioArtifactMetadata {
   archivedAt: number;
 }
 
-export type LiveVoiceAudioArchiveWarningCode =
+type LiveVoiceAudioArchiveWarningCode =
   | "archive_failed"
   | "attachment_not_found"
   | "invalid_audio_source"
@@ -591,7 +591,7 @@ type LinkLiveVoiceRolelessAudioInput = Omit<
   messageId?: string | null;
 };
 
-export interface LinkLiveVoiceAudioArtifactInput {
+interface LinkLiveVoiceAudioArtifactInput {
   messageId?: string | null;
   artifact: LiveVoiceAudioArtifactMetadata;
   position?: number;

package/src/live-voice/protocol.ts

@@ -6,8 +6,7 @@ const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "end",
 ] as const;
 
-export type LiveVoiceClientFrameType =
-  (typeof LIVE_VOICE_CLIENT_FRAME_TYPES)[number];
+type LiveVoiceClientFrameType = (typeof LIVE_VOICE_CLIENT_FRAME_TYPES)[number];
 
 const _LIVE_VOICE_SERVER_FRAME_TYPES = [
   "ready",
@@ -23,8 +22,7 @@ const _LIVE_VOICE_SERVER_FRAME_TYPES = [
   "error",
 ] as const;
 
-export type LiveVoiceServerFrameType =
-  (typeof _LIVE_VOICE_SERVER_FRAME_TYPES)[number];
+type LiveVoiceServerFrameType = (typeof _LIVE_VOICE_SERVER_FRAME_TYPES)[number];
 
 export const LiveVoiceProtocolErrorCode = {
   InvalidJson: "invalid_json",
@@ -45,7 +43,7 @@ export interface LiveVoiceProtocolError {
   readonly frameType?: string;
 }
 
-export type LiveVoiceParseResult<T> =
+type LiveVoiceParseResult<T> =
   | { ok: true; frame: T }
   | { ok: false; error: LiveVoiceProtocolError };
 
@@ -85,12 +83,12 @@ export type LiveVoiceClientFrame =
   | LiveVoiceClientInterruptFrame
   | LiveVoiceClientEndFrame;
 
-export interface LiveVoiceBinaryAudioFrame {
+interface LiveVoiceBinaryAudioFrame {
   readonly type: "binary_audio";
   readonly data: Uint8Array;
 }
 
-export interface LiveVoiceServerFrameBase {
+interface LiveVoiceServerFrameBase {
   readonly type: LiveVoiceServerFrameType;
   readonly seq: number;
 }

package/src/media/image-service.ts

@@ -76,10 +76,4 @@ export function providerForModel(
   return fallback;
 }
 
-export type {
-  GeneratedImage,
-  ImageGenCredentials,
-  ImageGenerationRequest,
-  ImageGenerationResult,
-  ImageGenProvider,
-} from "./types.js";
+export type { ImageGenCredentials } from "./types.js";

package/src/memory/__tests__/fixtures/memory-v2-activation-fixtures.ts

@@ -1,7 +1,6 @@
 import type {
   MemoryV2ConceptRowRecord,
   MemoryV2ConfigSnapshot,
-  MemoryV2SkillRowRecord,
 } from "../../memory-v2-activation-log-store.js";
 
 export const sampleConcepts: MemoryV2ConceptRowRecord[] = [
@@ -13,10 +12,28 @@ export const sampleConcepts: MemoryV2ConceptRowRecord[] = [
     simUser: 0.6,
     simAssistant: 0.4,
     simNow: 0.3,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
     spreadContribution: 0.2,
     source: "both",
     status: "injected",
   },
+  {
+    slug: "skills/skill-1",
+    finalActivation: 0.8,
+    ownActivation: 0.8,
+    priorActivation: 0,
+    simUser: 0.5,
+    simAssistant: 0.4,
+    simNow: 0.3,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
+    spreadContribution: 0,
+    source: "ann_top50",
+    status: "injected",
+  },
   {
     slug: "concept-b",
     finalActivation: 0.4,
@@ -25,23 +42,15 @@ export const sampleConcepts: MemoryV2ConceptRowRecord[] = [
     simUser: 0.2,
     simAssistant: 0.1,
     simNow: 0.05,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
     spreadContribution: 0.0,
     source: "ann_top50",
     status: "not_injected",
   },
 ];
 
-export const sampleSkills: MemoryV2SkillRowRecord[] = [
-  {
-    id: "skill-1",
-    activation: 0.8,
-    simUser: 0.5,
-    simAssistant: 0.4,
-    simNow: 0.3,
-    status: "injected",
-  },
-];
-
 export const sampleConfig: MemoryV2ConfigSnapshot = {
   d: 0.85,
   c_user: 1.0,
@@ -50,6 +59,5 @@ export const sampleConfig: MemoryV2ConfigSnapshot = {
   k: 5,
   hops: 2,
   top_k: 10,
-  top_k_skills: 3,
   epsilon: 0.001,
 };

package/src/memory/__tests__/jobs-worker-v2-schedule.test.ts

@@ -1,23 +1,23 @@
 /**
- * Tests for the v2 consolidation entry in `maybeEnqueueGraphMaintenanceJobs`.
+ * Tests for v1/v2 mutual exclusion in `maybeEnqueueGraphMaintenanceJobs`.
  *
- * Coverage matrix (from PR 24 acceptance criteria):
- *   - Flag off → no `memory_v2_consolidate` row enqueued, even after the
- *     interval has elapsed.
- *   - Flag on + config off → still no row enqueued (both gates required).
- *   - Flag on + config on, no prior checkpoint → row enqueued, checkpoint
- *     stamped to `nowMs`.
- *   - Flag on + config on, recent checkpoint → no row enqueued (interval
- *     not yet elapsed).
- *   - Flag on + config on, stale checkpoint → row enqueued, checkpoint
+ * The schedule is now mutually exclusive: when both the `memory-v2-enabled`
+ * flag and `memory.v2.enabled` config are on, only `memory_v2_consolidate`
+ * is scheduled; otherwise the four v1 entries (decay, consolidate,
+ * pattern_scan, narrative) fire and the v2 entry does not.
+ *
+ * Coverage:
+ *   - Flag off → only v1 entries fire (no `memory_v2_consolidate`).
+ *   - Flag on + config off → only v1 entries fire.
+ *   - Flag on + config on, no prior checkpoint → only the v2 entry fires.
+ *   - Flag on + config on, recent checkpoint → no v2 row (interval not
+ *     yet elapsed).
+ *   - Flag on + config on, stale checkpoint → v2 row enqueued, checkpoint
  *     refreshed.
- *   - The v1 maintenance entries (decay, consolidate, pattern_scan,
- *     narrative) still fire under the v2 path — adding the v2 entry must
- *     not regress v1 scheduling.
  *
- * The sweep job is intentionally NOT scheduled here: PR 24 wires it into
- * the `graph_extract` debounce in `indexer.ts`. Those triggers are covered
- * by the separate trigger-path tests; this file owns only the cron entries.
+ * The sweep job is intentionally NOT scheduled here: it is wired into the
+ * `graph_extract` debounce in `indexer.ts`. Those triggers are covered by
+ * the separate trigger-path tests; this file owns only the cron entries.
  *
  * Tests use a temp workspace pinned via `VELLUM_WORKSPACE_DIR` so the DB
  * lives under `tmpdir()` and `~/.vellum/` is never touched.
@@ -145,6 +145,11 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    // v1 entries are suppressed when v2 is active.
+    expect(countPendingJobs("graph_decay")).toBe(0);
+    expect(countPendingJobs("graph_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(0);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(0);
   });
 
   test("does not enqueue consolidate before the interval has elapsed", () => {
@@ -200,11 +205,30 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
   });
 
-  test("v1 graph maintenance entries still fire alongside the v2 entry", () => {
+  test("v1 maintenance entries are suppressed when v2 is active", () => {
     _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
-    // No checkpoints set — every entry should be due.
+    // No checkpoints set — every entry would be due if it were scheduled.
+    deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:narrative:last_run");
+    deleteMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY);
+
+    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
+
+    expect(countPendingJobs("graph_decay")).toBe(0);
+    expect(countPendingJobs("graph_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(0);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(0);
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+  });
+
+  test("flag-off path fires v1 entries and does not enqueue v2", () => {
+    _setOverridesForTesting({ "memory-v2-enabled": false });
+    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
+
     deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
     deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
     deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
@@ -217,19 +241,25 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("graph_consolidate")).toBe(1);
     expect(countPendingJobs("graph_pattern_scan")).toBe(1);
     expect(countPendingJobs("graph_narrative_refine")).toBe(1);
-    expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
 
-  test("flag-off path does not enqueue v2 but still fires the v1 entries", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
+  test("config-gate-off path fires v1 entries and does not enqueue v2", () => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    const config = buildConfig({ v2Enabled: false, intervalHours: 1 });
 
     deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:narrative:last_run");
     deleteMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY);
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
 
     expect(countPendingJobs("graph_decay")).toBe(1);
+    expect(countPendingJobs("graph_consolidate")).toBe(1);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(1);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(1);
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
 });

package/src/memory/__tests__/memory-v2-activation-log-store.test.ts

@@ -29,7 +29,6 @@ import { memoryV2ActivationLogs } from "../schema.js";
 import {
   sampleConcepts,
   sampleConfig,
-  sampleSkills,
 } from "./fixtures/memory-v2-activation-fixtures.js";
 
 initializeDb();
@@ -53,7 +52,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 3,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
 
@@ -65,7 +63,6 @@ describe("memory-v2-activation-log-store", () => {
     expect(result!.turn).toBe(3);
     expect(result!.mode).toBe("per-turn");
     expect(result!.concepts).toEqual(sampleConcepts);
-    expect(result!.skills).toEqual(sampleSkills);
     expect(result!.config).toEqual(sampleConfig);
   });
 
@@ -82,7 +79,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 1,
       mode: "context-load",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
     recordMemoryV2ActivationLog({
@@ -90,7 +86,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 2,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
 
@@ -110,7 +105,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 3,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });