@vellumai/assistant 0.5.2 → 0.5.3

package/src/__tests__/vellum-self-knowledge-inline-command.test.ts

@@ -0,0 +1,320 @@
+/**
+ * Tests that vellum-self-knowledge uses inline command expansion to inject
+ * the current assistant info at skill_load time.
+ *
+ * Validates that:
+ * - The `!\`bun run .../self-info.ts\`` token in SKILL.md is replaced by an
+ *   `<inline_skill_command>` block containing the runner's output.
+ * - The rest of the skill body (architecture, config, references, critical rule)
+ *   remains unchanged.
+ * - The inline command token does NOT appear verbatim in the loaded output
+ *   (i.e. the model is never told to shell out manually).
+ */
+
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Paths ──────────────────────────────────────────────────────────────────
+
+const TEST_DIR = mkdtempSync(
+  join(tmpdir(), "vellum-self-knowledge-inline-test-"),
+);
+
+/** Resolve the real skill directory so we can copy SKILL.md into the test. */
+const SKILL_SRC_DIR = join(
+  import.meta.dirname ?? __dirname,
+  "..",
+  "..",
+  "..",
+  "skills",
+  "vellum-self-knowledge",
+);
+
+// ── Mocks (must be declared before any imports from the project) ──────────
+
+const platformOverrides: Record<string, (...args: unknown[]) => unknown> = {
+  getRootDir: () => TEST_DIR,
+  getDataDir: () => join(TEST_DIR, "data"),
+  ensureDataDir: () => {},
+  getPidPath: () => join(TEST_DIR, "vellum.pid"),
+  getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
+  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
+  getWorkspaceDir: () => join(TEST_DIR, "workspace"),
+  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
+  getWorkspaceConfigPath: () => join(TEST_DIR, "workspace", "config.json"),
+  getWorkspaceHooksDir: () => join(TEST_DIR, "workspace", "hooks"),
+  getWorkspacePromptPath: (f: unknown) =>
+    join(TEST_DIR, "workspace", String(f)),
+  getInterfacesDir: () => join(TEST_DIR, "interfaces"),
+  getHooksDir: () => join(TEST_DIR, "hooks"),
+  getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
+  getSandboxWorkingDir: () => join(TEST_DIR, "sandbox", "work"),
+  getHistoryPath: () => join(TEST_DIR, "history"),
+  getSessionTokenPath: () => join(TEST_DIR, "session-token"),
+  readSessionToken: () => null,
+  getClipboardCommand: () => null,
+  readLockfile: () => null,
+  normalizeAssistantId: (id: unknown) => String(id),
+  writeLockfile: () => {},
+  getEmbeddingModelsDir: () => join(TEST_DIR, "embedding-models"),
+  getTCPPort: () => 8765,
+  isTCPEnabled: () => false,
+  getTCPHost: () => "127.0.0.1",
+  isIOSPairingEnabled: () => false,
+  getPlatformTokenPath: () => join(TEST_DIR, "platform-token"),
+  readPlatformToken: () => null,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPlatformName: () => process.platform,
+  getWorkspaceDirDisplay: () => "~/.vellum/workspace",
+  getConversationsDir: () => join(TEST_DIR, "conversations"),
+};
+mock.module("../util/platform.js", () => platformOverrides);
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (s: unknown) => String(s),
+}));
+
+// Track inline command runner calls
+interface RunInlineCommandCall {
+  command: string;
+  workingDir: string;
+}
+const runInlineCommandCalls: RunInlineCommandCall[] = [];
+
+/** Return type matching InlineCommandResult from the runner module. */
+interface MockInlineCommandResult {
+  output: string;
+  ok: boolean;
+  failureReason?:
+    | "timeout"
+    | "non_zero_exit"
+    | "binary_output"
+    | "spawn_failure";
+}
+
+type MockRunFn = (
+  command: string,
+  workingDir: string,
+) => Promise<MockInlineCommandResult>;
+
+// Default: commands succeed, returning a realistic self-info summary
+const MOCK_SELF_INFO_OUTPUT =
+  "You are running as Claude Opus 4.6 via Anthropic (your-own API key).";
+
+let mockRunInlineCommand = mock<MockRunFn>(
+  (command: string, workingDir: string) => {
+    runInlineCommandCalls.push({ command, workingDir });
+    return Promise.resolve({
+      output: MOCK_SELF_INFO_OUTPUT,
+      ok: true,
+    });
+  },
+);
+
+mock.module("../skills/inline-command-runner.js", () => ({
+  runInlineCommand: (command: string, workingDir: string, _options?: unknown) =>
+    mockRunInlineCommand(command, workingDir),
+}));
+
+// Mock autoInstallFromCatalog
+const mockAutoInstall = mock((_skillId: string) => Promise.resolve(false));
+mock.module("../skills/catalog-install.js", () => ({
+  autoInstallFromCatalog: (skillId: string) => mockAutoInstall(skillId),
+  resolveCatalog: (_skillId?: string) => Promise.resolve([]),
+}));
+
+interface TestConfig {
+  permissions: { mode: "strict" | "workspace" };
+  skills: { load: { extraDirs: string[] } };
+  sandbox: { enabled: boolean };
+  assistantFeatureFlagValues?: Record<string, boolean>;
+  [key: string]: unknown;
+}
+
+const testConfig: TestConfig = {
+  permissions: { mode: "workspace" },
+  skills: { load: { extraDirs: [] } },
+  sandbox: { enabled: true },
+  assistantFeatureFlagValues: {
+    "feature_flags.inline-skill-commands.enabled": true,
+  },
+};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => testConfig,
+  loadConfig: () => testConfig,
+  invalidateConfigCache: () => {},
+  saveConfig: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+// ── Imports (after mocks) ────────────────────────────────────────────────
+
+await import("../tools/skills/load.js");
+const { getTool } = await import("../tools/registry.js");
+
+// ── Helpers ──────────────────────────────────────────────────────────────
+
+/** Copy the real vellum-self-knowledge SKILL.md into the test skills dir. */
+function installSelfKnowledgeSkill(): void {
+  const destDir = join(TEST_DIR, "skills", "vellum-self-knowledge");
+  mkdirSync(destDir, { recursive: true });
+  copyFileSync(join(SKILL_SRC_DIR, "SKILL.md"), join(destDir, "SKILL.md"));
+  // Also copy references/ so that the reference listing still works
+  const refsSrc = join(SKILL_SRC_DIR, "references");
+  if (existsSync(refsSrc)) {
+    const refsDir = join(destDir, "references");
+    mkdirSync(refsDir, { recursive: true });
+    copyFileSync(join(refsSrc, "inference.md"), join(refsDir, "inference.md"));
+  }
+}
+
+async function executeSkillLoad(
+  input: Record<string, unknown>,
+  workingDir = "/tmp",
+): Promise<{ content: string; isError: boolean }> {
+  const tool = getTool("skill_load");
+  if (!tool) throw new Error("skill_load tool was not registered");
+
+  const result = await tool.execute(input, {
+    workingDir,
+    conversationId: "conversation-1",
+    trustClass: "guardian",
+  });
+  return { content: result.content, isError: result.isError };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────
+
+describe("vellum-self-knowledge inline command expansion", () => {
+  beforeEach(() => {
+    mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+    runInlineCommandCalls.length = 0;
+    mockAutoInstall.mockReset();
+    mockAutoInstall.mockImplementation(() => Promise.resolve(false));
+
+    // Reset to default: commands succeed with self-info output
+    mockRunInlineCommand = mock<MockRunFn>(
+      (command: string, workingDir: string) => {
+        runInlineCommandCalls.push({ command, workingDir });
+        return Promise.resolve({
+          output: MOCK_SELF_INFO_OUTPUT,
+          ok: true,
+        });
+      },
+    );
+    mock.module("../skills/inline-command-runner.js", () => ({
+      runInlineCommand: (
+        command: string,
+        workingDir: string,
+        _options?: unknown,
+      ) => mockRunInlineCommand(command, workingDir),
+    }));
+
+    // Enable the feature flag
+    testConfig.assistantFeatureFlagValues = {
+      "feature_flags.inline-skill-commands.enabled": true,
+    };
+    testConfig.skills = { load: { extraDirs: [] } };
+
+    installSelfKnowledgeSkill();
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  // ── Inline token replacement ─────────────────────────────────────────
+
+  test("inline token is replaced by an <inline_skill_command> block", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain(
+      `<inline_skill_command index="0">${MOCK_SELF_INFO_OUTPUT}</inline_skill_command>`,
+    );
+  });
+
+  test("the raw inline token does not appear in the loaded output", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.isError).toBe(false);
+    // The original `!\`...\`` token must be fully replaced
+    expect(result.content).not.toContain("!`bun run");
+    expect(result.content).not.toContain("scripts/self-info.ts`");
+  });
+
+  test("the model is not told to shell out manually", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.isError).toBe(false);
+    // The old instruction "Always run this script" should be gone
+    expect(result.content).not.toContain("Always run this script");
+    // No code block instructing manual execution
+    expect(result.content).not.toContain("```bash\nbun run");
+  });
+
+  // ── Runner invocation ────────────────────────────────────────────────
+
+  test("invokes the inline command runner with the self-info script command", async () => {
+    await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(runInlineCommandCalls).toHaveLength(1);
+    expect(runInlineCommandCalls[0].command).toContain("bun run");
+    expect(runInlineCommandCalls[0].command).toContain("scripts/self-info.ts");
+  });
+
+  // ── Rest of skill body preserved ─────────────────────────────────────
+
+  test("architecture section is preserved", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("## Architecture at a Glance");
+    expect(result.content).toContain("AgentLoop");
+  });
+
+  test("configuration section is preserved", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("## Configuration System");
+    expect(result.content).toContain("assistant config get");
+  });
+
+  test("references section is preserved", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("## When to Consult References");
+    expect(result.content).toContain("references/inference.md");
+  });
+
+  test("critical rule section is preserved", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("## Critical Rule");
+    expect(result.content).toContain(
+      "populated at skill-load time and reflects the live configuration",
+    );
+  });
+
+  test("what is vellum section is preserved", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("## What is Vellum");
+    expect(result.content).toContain("personal AI assistant platform");
+  });
+});

package/src/__tests__/workspace-migration-backfill-installation-id.test.ts

@@ -41,7 +41,7 @@ mock.module("../runtime/auth/external-assistant-id.js", () => ({
 }));
 
 // Import after mocking
-import { backfillInstallationIdMigration } from "../workspace/migrations/002-backfill-installation-id.js";
+import { backfillInstallationIdMigration } from "../workspace/migrations/011-backfill-installation-id.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -68,7 +68,7 @@ function setupFs(fileContents: Record<string, string>): void {
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("002-backfill-installation-id migration", () => {
+describe("011-backfill-installation-id migration", () => {
   beforeEach(() => {
     existsSyncFn.mockClear();
     readFileSyncFn.mockClear();
@@ -320,9 +320,9 @@ describe("002-backfill-installation-id migration", () => {
     expect(parsed.assistants[1].installationId).toBe("sqlite-id");
   });
 
-  test("has migration id 002-backfill-installation-id", () => {
+  test("has migration id 011-backfill-installation-id", () => {
     expect(backfillInstallationIdMigration.id).toBe(
-      "002-backfill-installation-id",
+      "011-backfill-installation-id",
     );
   });
 });

package/src/config/bundled-skills/app-builder/SKILL.md

@@ -20,10 +20,10 @@ You are an expert app builder and visual designer. When the user asks you to cre
 
 ## Filesystem Layout
 
-Apps live under `~/.vellum/workspace/data/apps/`. Each app has a slug-based layout:
+Apps live under `{workspaceDir}/data/apps/`. Each app has a slug-based layout:
 
 ```
-~/.vellum/workspace/data/apps/
+{workspaceDir}/data/apps/
   <slug>.json          # App metadata
   <slug>/              # App directory (contains all app files)
     index.html         # Main page (entry point rendered in WebView)
@@ -190,20 +190,20 @@ useEffect(() => {
 **Example - creating a multi-file project** (assuming app slug is `project-tracker`):
 
 ```
-file_write("~/.vellum/workspace/data/apps/project-tracker/src/index.html", `<!DOCTYPE html>
+file_write("{workspaceDir}/data/apps/project-tracker/src/index.html", `<!DOCTYPE html>
 <html lang="en">
 <head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>Project Tracker</title></head>
 <body><div id="app"></div></body>
 </html>`)
 
-file_write("~/.vellum/workspace/data/apps/project-tracker/src/main.tsx", `import { render } from 'preact';
+file_write("{workspaceDir}/data/apps/project-tracker/src/main.tsx", `import { render } from 'preact';
 import { App } from './components/App';
 import './styles.css';
 
 render(<App />, document.getElementById('app')!);`)
 
-file_write("~/.vellum/workspace/data/apps/project-tracker/src/components/App.tsx", `import { FunctionComponent } from 'preact';
+file_write("{workspaceDir}/data/apps/project-tracker/src/components/App.tsx", `import { FunctionComponent } from 'preact';
 import { useState, useEffect } from 'preact/hooks';
 import { Header } from './Header';
 
@@ -222,7 +222,7 @@ export const App: FunctionComponent = () => {
   );
 };`)
 
-file_write("~/.vellum/workspace/data/apps/project-tracker/src/components/Header.tsx", `import { FunctionComponent } from 'preact';
+file_write("{workspaceDir}/data/apps/project-tracker/src/components/Header.tsx", `import { FunctionComponent } from 'preact';
 
 interface HeaderProps {
   title: string;
@@ -236,7 +236,7 @@ export const Header: FunctionComponent<HeaderProps> = ({ title, count }) => (
   </header>
 );`)
 
-file_write("~/.vellum/workspace/data/apps/project-tracker/src/styles.css", `.app { padding: var(--v-spacing-lg); }
+file_write("{workspaceDir}/data/apps/project-tracker/src/styles.css", `.app { padding: var(--v-spacing-lg); }
 .header { display: flex; justify-content: space-between; align-items: center; }
 .badge { background: var(--v-accent); color: white; padding: var(--v-spacing-xs) var(--v-spacing-sm); border-radius: var(--v-radius-pill); }`)
 
@@ -532,7 +532,7 @@ The app is NOT opened in a workspace panel automatically - users open it via the
 
 When the user requests changes, prefer **`file_edit`** over rewriting the entire file.
 
-- **`file_edit`** - preferred for targeted changes (styles, bugs, features). Provide the full file path (e.g. `~/.vellum/workspace/data/apps/<slug>/src/components/App.tsx`).
+- **`file_edit`** - preferred for targeted changes (styles, bugs, features). Provide the full file path (e.g. `{workspaceDir}/data/apps/<slug>/src/components/App.tsx`).
 - **`file_write`** - for creating new files or full rewrites.
 - **`app_refresh`** - call ONCE after all file changes are complete to trigger compilation and surface refresh.
 - For metadata changes (`name`, `description`, `schemaJson`, etc.), edit the `<slug>.json` file directly with `file_edit`, then call `app_refresh`.

package/src/config/bundled-skills/skill-management/SKILL.md

@@ -7,7 +7,7 @@ metadata:
     display-name: "Skill Management"
 ---
 
-Manage the lifecycle of custom managed skills in `~/.vellum/workspace/skills`.
+Manage the lifecycle of custom managed skills in `{workspaceDir}/skills`.
 
 ## Capabilities
 

package/src/config/bundled-skills/skill-management/TOOLS.json

@@ -3,7 +3,7 @@
   "tools": [
     {
       "name": "scaffold_managed_skill",
-      "description": "Create or update a managed skill in ~/.vellum/workspace/skills. The skill becomes available for skill_load immediately. Never persist a skill without explicit user consent. Before persisting, test the snippet: write to a temp file with bash and run with `bun run /tmp/vellum-eval/snippet.ts`. Iterate up to 3 attempts, then ask the user. Clean up temp files after. Do not use file_write for temp files outside the working directory. After a skill is written, the next turn may run in a recreated conversation due to file-watcher eviction - continue normally.",
+      "description": "Create or update a managed skill in {workspaceDir}/skills. The skill becomes available for skill_load immediately. Never persist a skill without explicit user consent. Before persisting, test the snippet: write to a temp file with bash and run with `bun run /tmp/vellum-eval/snippet.ts`. Iterate up to 3 attempts, then ask the user. Clean up temp files after. Do not use file_write for temp files outside the working directory. After a skill is written, the next turn may run in a recreated conversation due to file-watcher eviction - continue normally.",
       "category": "skills",
       "risk": "high",
       "input_schema": {
@@ -54,7 +54,7 @@
     },
     {
       "name": "delete_managed_skill",
-      "description": "Delete a managed skill from ~/.vellum/workspace/skills and remove it from the SKILLS.md index. Never delete a skill without explicit user confirmation. After deletion, the next turn may run in a recreated conversation due to file-watcher eviction - continue normally.",
+      "description": "Delete a managed skill from {workspaceDir}/skills and remove it from the SKILLS.md index. Never delete a skill without explicit user confirmation. After deletion, the next turn may run in a recreated conversation due to file-watcher eviction - continue normally.",
       "category": "skills",
       "risk": "high",
       "input_schema": {

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

@@ -257,6 +257,14 @@
       "description": "Show the Google OAuth service card in Models & Services settings",
       "defaultEnabled": false
     },
+    {
+      "id": "settings-embedding-provider",
+      "scope": "assistant",
+      "key": "feature_flags.settings-embedding-provider.enabled",
+      "label": "Embedding Provider Settings",
+      "description": "Show the Embedding service card in Models & Services settings",
+      "defaultEnabled": false
+    },
     {
       "id": "quick-input",
       "scope": "macos",
@@ -272,6 +280,14 @@
       "label": "Expand Completed Steps",
       "description": "Auto-expand completed tool call step groups instead of showing them collapsed",
       "defaultEnabled": false
+    },
+    {
+      "id": "inline-skill-commands",
+      "scope": "assistant",
+      "key": "feature_flags.inline-skill-commands.enabled",
+      "label": "Inline Skill Command Expansion",
+      "description": "Enable secure inline skill command expansion via !`command` syntax, with version-pinned approval and sandboxed execution at skill load time",
+      "defaultEnabled": true
     }
   ]
 }

package/src/config/loader.ts

@@ -29,6 +29,7 @@ export const API_KEY_PROVIDERS = [
   "fireworks",
   "openrouter",
   "brave",
+  "elevenlabs",
   "perplexity",
 ] as const;
 

package/src/config/raw-config-utils.ts

@@ -58,3 +58,31 @@ export function setMemoryEmbeddingField(
   memory.embeddings = embeddings;
   raw.memory = memory;
 }
+
+/**
+ * Safely delete a nested field from a raw config object's `memory.embeddings`
+ * map, allowing Zod schema defaults to take effect on the next config reload.
+ */
+export function deleteMemoryEmbeddingField(
+  raw: Record<string, unknown>,
+  field: string,
+): void {
+  if (
+    raw.memory == null ||
+    typeof raw.memory !== "object" ||
+    Array.isArray(raw.memory)
+  ) {
+    return;
+  }
+  const memory = raw.memory as Record<string, unknown>;
+  const existing = memory.embeddings;
+  if (
+    existing == null ||
+    typeof existing !== "object" ||
+    Array.isArray(existing)
+  ) {
+    return;
+  }
+  const embeddings = existing as Record<string, unknown>;
+  delete embeddings[field];
+}

package/src/config/schema.ts

@@ -106,6 +106,18 @@ export {
   MemoryDynamicBudgetConfigSchema,
   MemoryRetrievalConfigSchema,
 } from "./schemas/memory-retrieval.js";
+export type {
+  MemorySimplifiedArchiveRecallConfig,
+  MemorySimplifiedBriefConfig,
+  MemorySimplifiedConfig,
+  MemorySimplifiedReducerConfig,
+} from "./schemas/memory-simplified.js";
+export {
+  MemorySimplifiedArchiveRecallConfigSchema,
+  MemorySimplifiedBriefConfigSchema,
+  MemorySimplifiedConfigSchema,
+  MemorySimplifiedReducerConfigSchema,
+} from "./schemas/memory-simplified.js";
 export type {
   MemoryEmbeddingsConfig,
   MemorySegmentationConfig,

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

@@ -0,0 +1,101 @@
+import { z } from "zod";
+
+export const MemorySimplifiedBriefConfigSchema = z
+  .object({
+    maxTokens: z
+      .number({
+        error: "memory.simplified.brief.maxTokens must be a number",
+      })
+      .int("memory.simplified.brief.maxTokens must be an integer")
+      .positive("memory.simplified.brief.maxTokens must be a positive integer")
+      .default(4000)
+      .describe(
+        "Maximum token budget for the memory brief injected into conversation context",
+      ),
+  })
+  .describe("Controls the memory brief that is injected into conversations");
+
+export const MemorySimplifiedReducerConfigSchema = z
+  .object({
+    idleDelayMs: z
+      .number({
+        error: "memory.simplified.reducer.idleDelayMs must be a number",
+      })
+      .int("memory.simplified.reducer.idleDelayMs must be an integer")
+      .positive(
+        "memory.simplified.reducer.idleDelayMs must be a positive integer",
+      )
+      .default(30_000)
+      .describe(
+        "Milliseconds of idle time before the reducer processes new conversation turns into memory",
+      ),
+    switchWaitMs: z
+      .number({
+        error: "memory.simplified.reducer.switchWaitMs must be a number",
+      })
+      .int("memory.simplified.reducer.switchWaitMs must be an integer")
+      .positive(
+        "memory.simplified.reducer.switchWaitMs must be a positive integer",
+      )
+      .default(5_000)
+      .describe(
+        "Milliseconds to wait after a conversation switch before running the reducer",
+      ),
+  })
+  .describe(
+    "Controls when the memory reducer runs to process conversation turns into persistent memory",
+  );
+
+export const MemorySimplifiedArchiveRecallConfigSchema = z
+  .object({
+    maxSnippets: z
+      .number({
+        error: "memory.simplified.archiveRecall.maxSnippets must be a number",
+      })
+      .int("memory.simplified.archiveRecall.maxSnippets must be an integer")
+      .positive(
+        "memory.simplified.archiveRecall.maxSnippets must be a positive integer",
+      )
+      .default(10)
+      .describe(
+        "Maximum number of archive snippets to recall when supplementing the brief with semantic search",
+      ),
+  })
+  .describe(
+    "Controls how archived memory snippets are recalled via semantic search",
+  );
+
+export const MemorySimplifiedConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({
+        error: "memory.simplified.enabled must be a boolean",
+      })
+      .default(false)
+      .describe("Whether the simplified memory system is enabled"),
+    brief: MemorySimplifiedBriefConfigSchema.default(
+      MemorySimplifiedBriefConfigSchema.parse({}),
+    ),
+    reducer: MemorySimplifiedReducerConfigSchema.default(
+      MemorySimplifiedReducerConfigSchema.parse({}),
+    ),
+    archiveRecall: MemorySimplifiedArchiveRecallConfigSchema.default(
+      MemorySimplifiedArchiveRecallConfigSchema.parse({}),
+    ),
+  })
+  .describe(
+    "Simplified two-layer memory system — a brief plus archive recall, replacing the legacy item/tier/staleness model",
+  );
+
+export type MemorySimplifiedConfig = z.infer<
+  typeof MemorySimplifiedConfigSchema
+>;
+export type MemorySimplifiedBriefConfig = z.infer<
+  typeof MemorySimplifiedBriefConfigSchema
+>;
+export type MemorySimplifiedReducerConfig = z.infer<
+  typeof MemorySimplifiedReducerConfigSchema
+>;
+export type MemorySimplifiedArchiveRecallConfig = z.infer<
+  typeof MemorySimplifiedArchiveRecallConfigSchema
+>;

package/src/config/schemas/memory.ts

@@ -10,6 +10,7 @@ import {
   MemorySummarizationConfigSchema,
 } from "./memory-processing.js";
 import { MemoryRetrievalConfigSchema } from "./memory-retrieval.js";
+import { MemorySimplifiedConfigSchema } from "./memory-simplified.js";
 import {
   MemoryEmbeddingsConfigSchema,
   MemorySegmentationConfigSchema,
@@ -45,6 +46,9 @@ export const MemoryConfigSchema = z
     summarization: MemorySummarizationConfigSchema.default(
       MemorySummarizationConfigSchema.parse({}),
     ),
+    simplified: MemorySimplifiedConfigSchema.default(
+      MemorySimplifiedConfigSchema.parse({}),
+    ),
   })
   .describe(
     "Long-term memory system — stores, retrieves, and manages persistent knowledge across conversations",