@vellumai/assistant 0.6.6 → 0.7.0

package/src/config/schemas/__tests__/memory-v2.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, test } from "bun:test";
+
+import { MemoryConfigSchema } from "../memory.js";
+import { MemoryV2ConfigSchema } from "../memory-v2.js";
+
+describe("MemoryV2ConfigSchema", () => {
+  test("parses an empty object to documented defaults", () => {
+    const parsed = MemoryV2ConfigSchema.parse({});
+    expect(parsed).toEqual({
+      enabled: false,
+      sweep_enabled: false,
+      d: 0.3,
+      c_user: 0.3,
+      c_assistant: 0.2,
+      c_now: 0.2,
+      k: 0.5,
+      hops: 2,
+      top_k: 20,
+      top_k_skills: 5,
+      epsilon: 0.01,
+      dense_weight: 0.7,
+      sparse_weight: 0.3,
+      consolidation_interval_hours: 4,
+      max_page_chars: 5000,
+    });
+  });
+
+  test("defaults satisfy both weight-sum constraints", () => {
+    const parsed = MemoryV2ConfigSchema.parse({});
+    expect(parsed.d + parsed.c_user + parsed.c_assistant + parsed.c_now).toBe(
+      1,
+    );
+    expect(parsed.dense_weight + parsed.sparse_weight).toBe(1);
+  });
+
+  test("accepts an explicit override that still sums to 1.0", () => {
+    const parsed = MemoryV2ConfigSchema.parse({
+      d: 0.4,
+      c_user: 0.3,
+      c_assistant: 0.2,
+      c_now: 0.1,
+    });
+    expect(parsed.d).toBe(0.4);
+    expect(parsed.c_user).toBe(0.3);
+    expect(parsed.c_assistant).toBe(0.2);
+    expect(parsed.c_now).toBe(0.1);
+  });
+
+  test("accepts hybrid weights that still sum to 1.0", () => {
+    const parsed = MemoryV2ConfigSchema.parse({
+      dense_weight: 0.5,
+      sparse_weight: 0.5,
+    });
+    expect(parsed.dense_weight).toBe(0.5);
+    expect(parsed.sparse_weight).toBe(0.5);
+  });
+
+  test("rejects activation weights that do not sum to 1.0", () => {
+    expect(() =>
+      MemoryV2ConfigSchema.parse({
+        d: 0.5,
+        c_user: 0.5,
+        c_assistant: 0.5,
+        c_now: 0.5,
+      }),
+    ).toThrow(/activation weights/);
+  });
+
+  test("rejects activation weights that sum to less than 1.0", () => {
+    expect(() =>
+      MemoryV2ConfigSchema.parse({
+        d: 0.1,
+        c_user: 0.1,
+        c_assistant: 0.1,
+        c_now: 0.1,
+      }),
+    ).toThrow(/activation weights/);
+  });
+
+  test("rejects hybrid weights that do not sum to 1.0", () => {
+    expect(() =>
+      MemoryV2ConfigSchema.parse({
+        dense_weight: 0.8,
+        sparse_weight: 0.5,
+      }),
+    ).toThrow(/hybrid weights/);
+  });
+
+  test("allows weight sums within the 0.001 tolerance and rejects beyond it", () => {
+    // Just inside the tolerance (gap ~0.0005) — accepted.
+    const ok = MemoryV2ConfigSchema.parse({
+      d: 0.3005,
+      c_user: 0.3,
+      c_assistant: 0.2,
+      c_now: 0.2,
+    });
+    expect(ok.d).toBe(0.3005);
+
+    // Beyond the tolerance (gap = 0.005) — rejected.
+    expect(() =>
+      MemoryV2ConfigSchema.parse({
+        d: 0.305,
+        c_user: 0.3,
+        c_assistant: 0.2,
+        c_now: 0.2,
+      }),
+    ).toThrow(/activation weights/);
+  });
+
+  test("rejects negative weight values", () => {
+    expect(() =>
+      MemoryV2ConfigSchema.parse({
+        d: -0.1,
+        c_user: 0.4,
+        c_assistant: 0.4,
+        c_now: 0.3,
+      }),
+    ).toThrow();
+  });
+
+  test("rejects non-integer hops", () => {
+    expect(() => MemoryV2ConfigSchema.parse({ hops: 1.5 })).toThrow();
+  });
+
+  test("rejects zero or negative top_k", () => {
+    expect(() => MemoryV2ConfigSchema.parse({ top_k: 0 })).toThrow();
+    expect(() => MemoryV2ConfigSchema.parse({ top_k: -5 })).toThrow();
+  });
+
+  test("rejects zero or negative consolidation_interval_hours", () => {
+    expect(() =>
+      MemoryV2ConfigSchema.parse({ consolidation_interval_hours: 0 }),
+    ).toThrow();
+  });
+
+  test("rejects zero or negative max_page_chars", () => {
+    expect(() => MemoryV2ConfigSchema.parse({ max_page_chars: 0 })).toThrow();
+  });
+
+  test("rejects non-boolean enabled", () => {
+    expect(() => MemoryV2ConfigSchema.parse({ enabled: "yes" })).toThrow();
+  });
+
+  test("rejects epsilon outside [0, 1]", () => {
+    expect(() => MemoryV2ConfigSchema.parse({ epsilon: -0.01 })).toThrow();
+    expect(() => MemoryV2ConfigSchema.parse({ epsilon: 1.5 })).toThrow();
+  });
+});
+
+describe("MemoryConfigSchema integration with v2 block", () => {
+  test("parses an empty memory config and includes a v2 block with defaults", () => {
+    const parsed = MemoryConfigSchema.parse({});
+    expect(parsed.v2).toBeDefined();
+    expect(parsed.v2.enabled).toBe(false);
+    expect(parsed.v2.sweep_enabled).toBe(false);
+    expect(parsed.v2.d).toBe(0.3);
+    expect(parsed.v2.dense_weight).toBe(0.7);
+    expect(parsed.v2.sparse_weight).toBe(0.3);
+    expect(parsed.v2.top_k_skills).toBe(5);
+    expect(parsed.v2.consolidation_interval_hours).toBe(4);
+    expect(parsed.v2.max_page_chars).toBe(5000);
+  });
+
+  test("propagates v2 overrides through MemoryConfigSchema", () => {
+    const parsed = MemoryConfigSchema.parse({
+      v2: { enabled: true, top_k: 50 },
+    });
+    expect(parsed.v2.enabled).toBe(true);
+    expect(parsed.v2.top_k).toBe(50);
+    // Non-overridden v2 fields keep their defaults.
+    expect(parsed.v2.d).toBe(0.3);
+  });
+
+  test("rejects invalid v2 weights when nested in MemoryConfigSchema", () => {
+    expect(() =>
+      MemoryConfigSchema.parse({
+        v2: {
+          d: 0.5,
+          c_user: 0.5,
+          c_assistant: 0.5,
+          c_now: 0.5,
+        },
+      }),
+    ).toThrow(/activation weights/);
+  });
+});

package/src/config/schemas/filing.ts

@@ -14,6 +14,18 @@ export const FilingConfigSchema = z
       .positive("filing.intervalMs must be a positive integer")
       .default(4 * 3_600_000)
       .describe("Time between filing runs in milliseconds"),
+    compactionEnabled: z
+      .boolean({ error: "filing.compactionEnabled must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether the daily PKB compaction job is enabled — audits file sizes, splits oversized files, consolidates duplicates, and prunes stale threads",
+      ),
+    compactionIntervalMs: z
+      .number({ error: "filing.compactionIntervalMs must be a number" })
+      .int("filing.compactionIntervalMs must be an integer")
+      .positive("filing.compactionIntervalMs must be a positive integer")
+      .default(24 * 3_600_000)
+      .describe("Time between compaction runs in milliseconds"),
     activeHoursStart: z
       .number({ error: "filing.activeHoursStart must be a number" })
       .int("filing.activeHoursStart must be an integer")

package/src/config/schemas/host-browser.ts

@@ -12,7 +12,7 @@ import { z } from "zod";
  * skips the probe for subsequent calls until the cooldown expires. This bounds
  * the per-call latency penalty to `probeTimeoutMs` once per cooldown window.
  */
-export const DesktopAutoCdpInspectConfigSchema = z
+const DesktopAutoCdpInspectConfigSchema = z
   .object({
     enabled: z
       .boolean({
@@ -49,7 +49,7 @@ export type DesktopAutoCdpInspectConfig = z.infer<
  * (e.g. `chrome://inspect`-style remote debugging) as an alternative to the
  * extension or local Playwright backend.
  */
-export const HostBrowserCdpInspectConfigSchema = z
+const HostBrowserCdpInspectConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "hostBrowser.cdpInspect.enabled must be a boolean" })

package/src/config/schemas/inference.ts

@@ -6,8 +6,6 @@ const VALID_LATEST_TURN_COMPRESSION_POLICIES = [
   "drop",
 ] as const;
 
-export { VALID_LATEST_TURN_COMPRESSION_POLICIES };
-
 export const ThinkingConfigSchema = z
   .object({
     enabled: z

package/src/config/schemas/ingress.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-export const IngressWebhookConfigSchema = z
+const IngressWebhookConfigSchema = z
   .object({
     secret: z
       .string({ error: "ingress.webhook.secret must be a string" })

package/src/config/schemas/llm.ts

@@ -13,7 +13,7 @@ import { z } from "zod";
 // Provider enum
 // ---------------------------------------------------------------------------
 
-export const LLMProvider = z.enum([
+const LLMProvider = z.enum([
   "anthropic",
   "openai",
   "gemini",
@@ -21,7 +21,7 @@ export const LLMProvider = z.enum([
   "fireworks",
   "openrouter",
 ]);
-export type LLMProvider = z.infer<typeof LLMProvider>;
+type LLMProvider = z.infer<typeof LLMProvider>;
 
 // ---------------------------------------------------------------------------
 // Call-site enum
@@ -39,11 +39,15 @@ export const LLMCallSiteEnum = z.enum([
   "subagentSpawn",
   "heartbeatAgent",
   "filingAgent",
+  "compactionAgent",
   "analyzeConversation",
   "callAgent",
   "memoryExtraction",
   "memoryConsolidation",
   "memoryRetrieval",
+  "memoryV2Migration",
+  "memoryV2Sweep",
+  "recall",
   "narrativeRefinement",
   "patternScan",
   "conversationSummarization",
@@ -65,19 +69,41 @@ export const LLMCallSiteEnum = z.enum([
   "meetChatOpportunity",
   "inference",
   "feedEventCopy",
+  "trustRuleSuggestion",
 ]);
 export type LLMCallSite = z.infer<typeof LLMCallSiteEnum>;
 
 // ---------------------------------------------------------------------------
-// Effort & Speed
+// Effort, Speed & Verbosity
 // ---------------------------------------------------------------------------
 
-export const EffortEnum = z.enum(["low", "medium", "high", "xhigh", "max"]);
+/**
+ * Reasoning/thinking effort tier. `"none"` is a Vellum-specific value meaning
+ * "the user has opted out of provider-side reasoning". Each provider
+ * translates it however actually disables reasoning on that wire format:
+ * OpenAI Responses sends `reasoning.effort: "none"` and Chat Completions
+ * sends `reasoning_effort: "none"` explicitly, because omitting the field
+ * causes OpenAI to default to `"medium"`; Anthropic omits
+ * `output_config.effort` entirely, which is the documented opt-out there.
+ * When adding a new provider, pick whichever encoding actually disables
+ * reasoning on that wire format — do not assume omission is universally safe.
+ * All other values map to provider-specific tiers via each provider's own
+ * mapping table.
+ */
+const EffortEnum = z.enum(["none", "low", "medium", "high", "xhigh", "max"]);
 export type Effort = z.infer<typeof EffortEnum>;
 
 export const SpeedEnum = z.enum(["standard", "fast"]);
 export type Speed = z.infer<typeof SpeedEnum>;
 
+/**
+ * Response verbosity. Currently consumed by OpenAI's Responses API as
+ * `text.verbosity` (low|medium|high). Providers that don't support this knob
+ * are stripped in `retry.ts` normalization.
+ */
+const VerbosityEnum = z.enum(["low", "medium", "high"]);
+export type Verbosity = z.infer<typeof VerbosityEnum>;
+
 // ---------------------------------------------------------------------------
 // Leaf primitives (shared between LLMConfigBase and LLMConfigFragment)
 //
@@ -120,7 +146,7 @@ const TemperatureSchema = z.number().min(0).max(2).nullable();
 const ThinkingEnabledSchema = z.boolean();
 const ThinkingStreamThinkingSchema = z.boolean();
 
-export const ThinkingSchema = z.object({
+const ThinkingSchema = z.object({
   enabled: ThinkingEnabledSchema.default(true),
   streamThinking: ThinkingStreamThinkingSchema.default(true),
 });
@@ -172,7 +198,7 @@ const ContextTargetBudgetRatioSchema = z.number().finite().gt(0).lte(1);
 const ContextCompactThresholdSchema = z.number().finite().gt(0).lte(1);
 const ContextSummaryBudgetRatioSchema = z.number().finite().gt(0).lte(1);
 
-export const ContextWindowSchema = z.object({
+const ContextWindowSchema = z.object({
   enabled: ContextEnabledSchema.default(true),
   maxInputTokens: ContextMaxInputTokensSchema.default(200000),
   targetBudgetRatio: ContextTargetBudgetRatioSchema.default(0.3),
@@ -210,7 +236,7 @@ const ContextWindowDeepPartialSchema = z.object({
 
 const OpenRouterOnlyItemSchema = z.string().min(1);
 
-export const OpenRouterSchema = z.object({
+const OpenRouterSchema = z.object({
   only: z.array(OpenRouterOnlyItemSchema).default([]),
 });
 export type OpenRouter = z.infer<typeof OpenRouterSchema>;
@@ -223,7 +249,7 @@ const OpenRouterDeepPartialSchema = z.object({
 // Pricing overrides
 // ---------------------------------------------------------------------------
 
-export const PricingOverrideSchema = z.object({
+const PricingOverrideSchema = z.object({
   provider: z.string(),
   modelPattern: z.string(),
   inputPer1M: z.number().nonnegative(),
@@ -243,10 +269,11 @@ export type PricingOverride = z.infer<typeof PricingOverrideSchema>;
  */
 export const LLMConfigBase = z.object({
   provider: LLMProvider.default("anthropic"),
-  model: ModelSchema.default("claude-sonnet-4-6"),
+  model: ModelSchema.default("claude-opus-4-7"),
   maxTokens: MaxTokensSchema.default(64000),
   effort: EffortEnum.default("max"),
   speed: SpeedEnum.default("standard"),
+  verbosity: VerbosityEnum.default("medium"),
   temperature: TemperatureSchema.default(null),
   thinking: ThinkingSchema.default(ThinkingSchema.parse({})),
   contextWindow: ContextWindowSchema.default(ContextWindowSchema.parse({})),
@@ -266,6 +293,7 @@ export const LLMConfigFragment = z.object({
   maxTokens: MaxTokensSchema.optional(),
   effort: EffortEnum.optional(),
   speed: SpeedEnum.optional(),
+  verbosity: VerbosityEnum.optional(),
   temperature: TemperatureSchema.optional(),
   thinking: ThinkingFragmentSchema.optional(),
   contextWindow: ContextWindowDeepPartialSchema.optional(),
@@ -291,6 +319,9 @@ export const LLMSchema = z
   .object({
     default: LLMConfigBase.default(LLMConfigBase.parse({})),
     profiles: z.record(z.string().min(1), LLMConfigFragment).default({}),
+    // Presentation-only order for named profiles. The resolver ignores this;
+    // clients use it to render profile pickers consistently.
+    profileOrder: z.array(z.string().min(1)).default([]),
     // `partialRecord` (vs `record`) makes call-site keys optional while still
     // rejecting keys that aren't members of `LLMCallSiteEnum` — exactly the
     // behavior we want (typo detection without requiring callers to declare
@@ -298,6 +329,7 @@ export const LLMSchema = z
     // are seeded into the user's on-disk config by migration 040, not at
     // schema level, so `LLMSchema.parse({})` yields an empty map.
     callSites: z.partialRecord(LLMCallSiteEnum, LLMCallSiteConfig).default({}),
+    activeProfile: z.string().min(1).optional(),
     pricingOverrides: z.array(PricingOverrideSchema).default([]),
   })
   .superRefine((config, ctx) => {
@@ -312,6 +344,16 @@ export const LLMSchema = z
         });
       }
     }
+    if (
+      config.activeProfile != null &&
+      !profileNames.has(config.activeProfile)
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["activeProfile"],
+        message: `Profile "${config.activeProfile}" referenced by llm.activeProfile is not defined in llm.profiles`,
+      });
+    }
   });
 
 export type LLMConfig = z.infer<typeof LLMSchema>;

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

@@ -38,7 +38,7 @@ export const MemoryEmbeddingsConfigSchema = z
       .describe("Model name for the OpenAI embedding provider"),
     geminiModel: z
       .string({ error: "memory.embeddings.geminiModel must be a string" })
-      .default("gemini-embedding-2-preview")
+      .default("gemini-embedding-2")
       .describe("Model name for the Gemini embedding provider"),
     geminiTaskType: z
       .enum(

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

@@ -0,0 +1,176 @@
+import { z } from "zod";
+
+/**
+ * Tolerance for floating-point comparisons of weight sums. Using 0.001 lets
+ * users specify weights to three decimal places without spurious rejections,
+ * while still catching obvious mis-sums.
+ */
+const WEIGHT_SUM_TOLERANCE = 0.001;
+
+/**
+ * Memory v2 (concept-page activation model) configuration.
+ *
+ * Activation weights (`d`, `c_user`, `c_assistant`, `c_now`) must sum to 1.0
+ * because they form a convex combination in the per-turn activation formula:
+ *   A_o = d·prev + c_user·sim_u + c_assistant·sim_a + c_now·sim_n
+ *
+ * Hybrid retrieval weights (`dense_weight`, `sparse_weight`) must likewise
+ * sum to 1.0 since they fuse normalized dense and sparse similarity scores.
+ */
+export const MemoryV2ConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "memory.v2.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Whether the v2 memory subsystem (concept-page activation model) is enabled. Independent of the memory-v2-enabled feature flag — both must be true for v2 to run.",
+      ),
+    sweep_enabled: z
+      .boolean({ error: "memory.v2.sweep_enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Whether the v2 idle-debounced sweep job is enabled. Off by default — `remember()` is the primary capture path; opt in only when the model is missing entries the sweep would have caught.",
+      ),
+    d: z
+      .number({ error: "memory.v2.d must be a number" })
+      .min(0, "memory.v2.d must be >= 0")
+      .max(1, "memory.v2.d must be <= 1")
+      .default(0.3)
+      .describe(
+        "Decay weight on prior activation in the per-turn activation formula",
+      ),
+    c_user: z
+      .number({ error: "memory.v2.c_user must be a number" })
+      .min(0, "memory.v2.c_user must be >= 0")
+      .max(1, "memory.v2.c_user must be <= 1")
+      .default(0.3)
+      .describe(
+        "Weight on similarity to the latest user message in the per-turn activation formula",
+      ),
+    c_assistant: z
+      .number({ error: "memory.v2.c_assistant must be a number" })
+      .min(0, "memory.v2.c_assistant must be >= 0")
+      .max(1, "memory.v2.c_assistant must be <= 1")
+      .default(0.2)
+      .describe(
+        "Weight on similarity to the latest assistant message in the per-turn activation formula",
+      ),
+    c_now: z
+      .number({ error: "memory.v2.c_now must be a number" })
+      .min(0, "memory.v2.c_now must be >= 0")
+      .max(1, "memory.v2.c_now must be <= 1")
+      .default(0.2)
+      .describe(
+        "Weight on similarity to NOW context (essentials/threads/recent) in the per-turn activation formula",
+      ),
+    k: z
+      .number({ error: "memory.v2.k must be a number" })
+      .min(0, "memory.v2.k must be >= 0")
+      .max(1, "memory.v2.k must be <= 1")
+      .default(0.5)
+      .describe(
+        "Spreading-activation propagation coefficient — fraction of own activation that flows to neighbors per hop",
+      ),
+    hops: z
+      .number({ error: "memory.v2.hops must be a number" })
+      .int("memory.v2.hops must be an integer")
+      .nonnegative("memory.v2.hops must be non-negative")
+      .default(2)
+      .describe(
+        "Maximum BFS distance for spreading activation across the concept graph",
+      ),
+    top_k: z
+      .number({ error: "memory.v2.top_k must be a number" })
+      .int("memory.v2.top_k must be an integer")
+      .positive("memory.v2.top_k must be a positive integer")
+      .default(20)
+      .describe(
+        "Number of top-activation concept pages considered for injection per turn",
+      ),
+    top_k_skills: z
+      .number({ error: "memory.v2.top_k_skills must be a number" })
+      .int()
+      .nonnegative()
+      .default(5)
+      .describe(
+        "Cap on the per-turn skill-autoinjection slate rendered in `### Skills You Can Use`. 0 disables skill autoinjection without code changes.",
+      ),
+    epsilon: z
+      .number({ error: "memory.v2.epsilon must be a number" })
+      .min(0, "memory.v2.epsilon must be >= 0")
+      .max(1, "memory.v2.epsilon must be <= 1")
+      .default(0.01)
+      .describe(
+        "Activation cutoff — slugs with activation <= epsilon are dropped from the persisted state",
+      ),
+    dense_weight: z
+      .number({ error: "memory.v2.dense_weight must be a number" })
+      .min(0, "memory.v2.dense_weight must be >= 0")
+      .max(1, "memory.v2.dense_weight must be <= 1")
+      .default(0.7)
+      .describe(
+        "Weight on dense (cosine) similarity in the hybrid retrieval score",
+      ),
+    sparse_weight: z
+      .number({ error: "memory.v2.sparse_weight must be a number" })
+      .min(0, "memory.v2.sparse_weight must be >= 0")
+      .max(1, "memory.v2.sparse_weight must be <= 1")
+      .default(0.3)
+      .describe(
+        "Weight on sparse (BM25-style) similarity in the hybrid retrieval score",
+      ),
+    consolidation_interval_hours: z
+      .number({
+        error: "memory.v2.consolidation_interval_hours must be a number",
+      })
+      .int("memory.v2.consolidation_interval_hours must be an integer")
+      .positive(
+        "memory.v2.consolidation_interval_hours must be a positive integer",
+      )
+      .default(4)
+      .describe(
+        "Hours between scheduled consolidation runs that synthesize buffered memories into concept pages",
+      ),
+    max_page_chars: z
+      .number({ error: "memory.v2.max_page_chars must be a number" })
+      .int("memory.v2.max_page_chars must be an integer")
+      .positive("memory.v2.max_page_chars must be a positive integer")
+      .default(5000)
+      .describe(
+        "Soft upper bound on concept-page body length — pages exceeding this are flagged for split during consolidation",
+      ),
+  })
+  .describe(
+    "Memory v2 — concept-page activation model with hourly LLM-driven consolidation",
+  )
+  .superRefine((config, ctx) => {
+    const activationSum =
+      config.d + config.c_user + config.c_assistant + config.c_now;
+    if (Math.abs(activationSum - 1.0) >= WEIGHT_SUM_TOLERANCE) {
+      const message = `memory.v2 activation weights (d + c_user + c_assistant + c_now) must sum to 1.0 (got ${activationSum.toFixed(4)})`;
+      // Emit on every contributing field so validateWithSchema's
+      // delete-and-retry repair can strip the offending values and fall
+      // back to the documented defaults rather than wiping the whole v2
+      // block.
+      for (const path of ["d", "c_user", "c_assistant", "c_now"] as const) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [path],
+          message,
+        });
+      }
+    }
+    const hybridSum = config.dense_weight + config.sparse_weight;
+    if (Math.abs(hybridSum - 1.0) >= WEIGHT_SUM_TOLERANCE) {
+      const message = `memory.v2 hybrid weights (dense_weight + sparse_weight) must sum to 1.0 (got ${hybridSum.toFixed(4)})`;
+      for (const path of ["dense_weight", "sparse_weight"] as const) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [path],
+          message,
+        });
+      }
+    }
+  });
+
+export type MemoryV2Config = z.infer<typeof MemoryV2ConfigSchema>;

package/src/config/schemas/memory.ts

@@ -15,6 +15,7 @@ import {
   MemorySegmentationConfigSchema,
   QdrantConfigSchema,
 } from "./memory-storage.js";
+import { MemoryV2ConfigSchema } from "./memory-v2.js";
 
 export const MemoryConfigSchema = z
   .object({
@@ -45,6 +46,7 @@ export const MemoryConfigSchema = z
     summarization: MemorySummarizationConfigSchema.default(
       MemorySummarizationConfigSchema.parse({}),
     ),
+    v2: MemoryV2ConfigSchema.default(MemoryV2ConfigSchema.parse({})),
   })
   .describe(
     "Long-term memory system — stores, retrieves, and manages persistent knowledge across conversations",

package/src/config/schemas/security.ts

@@ -1,9 +1,6 @@
 import { z } from "zod";
 
 const VALID_SECRET_ACTIONS = ["redact", "warn", "block", "prompt"] as const;
-const VALID_PERMISSIONS_MODES = ["strict", "workspace"] as const;
-
-export { VALID_PERMISSIONS_MODES, VALID_SECRET_ACTIONS };
 
 const CustomSecretPatternSchema = z
   .object({
@@ -67,61 +64,4 @@ export const SecretDetectionConfigSchema = z
     "Automatic secret detection and redaction to prevent leaking sensitive data",
   );
 
-export const PermissionsConfigSchema = z
-  .object({
-    mode: z
-      .enum(VALID_PERMISSIONS_MODES, {
-        error: `permissions.mode must be one of: ${VALID_PERMISSIONS_MODES.join(
-          ", ",
-        )}`,
-      })
-      .default("workspace")
-      .describe(
-        "Permission mode — 'strict' requires explicit approval for all operations, 'workspace' allows operations within the workspace",
-      ),
-    hostAccess: z
-      .boolean({
-        error: "permissions.hostAccess must be a boolean",
-      })
-      .default(false)
-      .describe(
-        "Whether the assistant can execute commands on the host machine without prompting",
-      ),
-    autoApproveUpTo: z
-      .union([
-        z.enum(["none", "low", "medium", "high"], {
-          error:
-            "permissions.autoApproveUpTo must be one of: none, low, medium, high",
-        }),
-        z.object({
-          conversation: z
-            .enum(["none", "low", "medium", "high"])
-            .default("low")
-            .describe(
-              "Threshold for interactive conversation sessions (default: low)",
-            ),
-          background: z
-            .enum(["none", "low", "medium", "high"])
-            .default("medium")
-            .describe(
-              "Threshold for non-interactive guardian sessions (default: medium)",
-            ),
-          headless: z
-            .enum(["none", "low", "medium", "high"])
-            .default("none")
-            .describe(
-              "Threshold for non-interactive non-guardian sessions (default: none)",
-            ),
-        }),
-      ])
-      .default({ conversation: "low", background: "medium", headless: "none" })
-      .describe(
-        "Auto-approve tools at or below this risk level without prompting. " +
-          "Accepts a scalar ('none', 'low', 'medium', 'high') applied to all contexts, " +
-          "or an object with per-context overrides: { conversation, background, headless }.",
-      ),
-  })
-  .describe("Permission enforcement mode for tool operations");
-
 export type SecretDetectionConfig = z.infer<typeof SecretDetectionConfigSchema>;
-export type PermissionsConfig = z.infer<typeof PermissionsConfigSchema>;