@vellumai/assistant 0.10.4-staging.1 → 0.10.4

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

@@ -29,6 +29,10 @@
             "type": "string",
             "description": "Optional emoji icon for the skill."
           },
+          "category": {
+            "type": "string",
+            "description": "Optional single lowercase category for grouping the skill in the Skills UI sidebar. Must be one of the published categories — a value outside this list shows under All with no sidebar bucket, so always pick the closest fit: browsing, calendar, commerce, content, development, email, health, integrations, messaging, productivity, system, voice."
+          },
           "overwrite": {
             "type": "boolean",
             "description": "Whether to overwrite an existing skill with the same ID (default: false)."
@@ -38,6 +42,24 @@
             "items": { "type": "string" },
             "description": "Optional list of child skill IDs that this skill includes (metadata only, no auto-activation)."
           },
+          "files": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "path": {
+                  "type": "string",
+                  "description": "Path relative to the skill directory (e.g. \"references/failure-modes.md\"). Absolute paths and \"..\" segments are rejected."
+                },
+                "content": {
+                  "type": "string",
+                  "description": "File contents."
+                }
+              },
+              "required": ["path", "content"]
+            },
+            "description": "Optional companion files written under the skill directory (e.g. references/*.md referenced from SKILL.md). Paths must resolve inside the skill folder."
+          },
           "add_to_index": {
             "type": "boolean",
             "description": "Deprecated no-op compatibility field. Skills are discovered from top-level SKILL.md files."
@@ -69,6 +91,29 @@
       },
       "executor": "tools/delete-managed.ts",
       "execution_target": "host"
+    },
+    {
+      "name": "find_similar_skills",
+      "description": "Find the existing skills most similar to a goal. Scores the goal against the skill catalog's capability pages and returns a ranked shortlist of nearest skills, each with its name, description, source (bundled, managed, plugin, workspace, or extra), and similarity score. For a managed hit it also returns `author` — \"assistant\" if the assistant authored that skill (so it may be overwritten) or \"user\" if a person did (off-limits); `author` is omitted for non-managed sources and for managed skills with no recorded author. Read-only — it never creates, edits, or deletes anything.",
+      "category": "skills",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "goal": {
+            "type": "string",
+            "description": "The goal or intent to match against existing skills."
+          },
+          "limit": {
+            "type": "integer",
+            "minimum": 1,
+            "description": "Maximum number of nearest skills to return (default: 5)."
+          }
+        },
+        "required": ["goal"]
+      },
+      "executor": "tools/find-similar.ts",
+      "execution_target": "host"
     }
   ]
 }

package/src/config/bundled-skills/skill-management/tools/find-similar.ts

@@ -0,0 +1,12 @@
+import { executeFindSimilarSkills } from "../../../../tools/skills/find-similar-skills.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeFindSimilarSkills(input, context);
+}

package/src/config/bundled-tool-registry.ts

@@ -118,6 +118,7 @@ import * as openSystemSettings from "./bundled-skills/settings/tools/open-system
 import * as voiceConfigUpdate from "./bundled-skills/settings/tools/voice-config-update.js";
 // ── skill-management ───────────────────────────────────────────────────────────
 import * as deleteManaged from "./bundled-skills/skill-management/tools/delete-managed.js";
+import * as findSimilarSkills from "./bundled-skills/skill-management/tools/find-similar.js";
 import * as scaffoldManaged from "./bundled-skills/skill-management/tools/scaffold-managed.js";
 // ── subagent ───────────────────────────────────────────────────────────────────
 import * as subagentAbort from "./bundled-skills/subagent/tools/subagent-abort.js";
@@ -262,6 +263,7 @@ export const bundledToolRegistry = new Map<string, SkillToolScript>([
   // skill-management
   ["skill-management:tools/scaffold-managed.ts", scaffoldManaged],
   ["skill-management:tools/delete-managed.ts", deleteManaged],
+  ["skill-management:tools/find-similar.ts", findSimilarSkills],
 
   // subagent
   ["subagent:tools/subagent-spawn.ts", subagentSpawn],

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

@@ -266,14 +266,6 @@
       "description": "Show the 'Analyze' / 'Analyze conversation' option in conversation context menus and the conversation title actions dropdown.",
       "defaultEnabled": false
     },
-    {
-      "id": "external-plugins",
-      "scope": "assistant",
-      "key": "external-plugins",
-      "label": "External Plugins",
-      "description": "Enable the external-plugin install path: the `assistant plugins` CLI subcommand and the declarative external-plugin loader convention (`<workspaceDir>/plugins/<name>/` directories containing `package.json` plus interface dirs). Gates an unstable surface that may change shape before stabilizing.",
-      "defaultEnabled": false
-    },
     {
       "id": "velvet-theme",
       "scope": "client",
@@ -370,14 +362,6 @@
       "description": "Expose the developer-only Memory Router Playground tab in macOS Settings and the /assistant/memory-router-playground web page for dry-running v4 router config overrides against the live page index. Dev-only; default off.",
       "defaultEnabled": false
     },
-    {
-      "id": "memory-v3-shadow",
-      "scope": "assistant",
-      "key": "memory-v3-shadow",
-      "label": "Memory v3 Shadow",
-      "description": "When on, runs the new memory-v3 topic-tree retrieval alongside v2 in shadow mode: logs selections to memory_v3_selections, does not modify injected context. Off by default.",
-      "defaultEnabled": false
-    },
     {
       "id": "self-intro-greeting",
       "scope": "both",
@@ -417,6 +401,14 @@
       "label": "OS Beta",
       "description": "Enable the OS Beta model profile (MiniMax M3 / Together) in the assistant's model profile selection.",
       "defaultEnabled": false
+    },
+    {
+      "id": "new-thread-suggestions",
+      "scope": "client",
+      "key": "new-thread-suggestions",
+      "label": "New-thread suggestions library",
+      "description": "Replace the empty-state conversation-starter chips with the scrollable, categorized suggestions library and detail drawer (currently mocked data).",
+      "defaultEnabled": false
     }
   ]
 }

package/src/config/llm-resolver.ts

@@ -352,6 +352,23 @@ export function resolveDefaultProfileKey(
   return undefined;
 }
 
+/**
+ * Stable non-null identity for profileless configs. Callers should prefer real
+ * profile keys first; when no named profile applies, the resolved model id is
+ * the only model-selection identifier available.
+ */
+export function resolveProfilelessModelKey(
+  callSite: LLMCallSite,
+  llm: z.infer<typeof LLMSchema>,
+  opts: ResolveCallSiteOpts = {},
+): string {
+  try {
+    return resolveCallSiteConfig(callSite, llm, opts).model;
+  } catch {
+    return llm.default?.model ?? "default";
+  }
+}
+
 function effectiveDefault(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,

package/src/config/loader.ts

@@ -127,6 +127,15 @@ export function getDeploymentContextDefaults(): Record<string, unknown> {
   // search for providers/models that support it.
   const managed = { mode: "managed" as const };
   return {
+    // Express platform intent that hosted assistants embed via the managed
+    // Gemini backend. Fill-only (applied in-memory by
+    // `fillContextDefaultsForMissingKeys`), so it expresses the default without
+    // persisting it or overriding an explicit on-disk provider. The committed
+    // dimension (`memory.qdrant.vectorSize`) and `geminiModel` are NOT set here:
+    // the dimension is derived at startup by the embedding-identity reconcile
+    // from a live backend probe, and `geminiModel` carries its own schema
+    // default (`gemini-embedding-2`).
+    memory: { embeddings: { provider: "gemini" } },
     services: {
       "image-generation": managed,
       "web-search": managed,
@@ -680,8 +689,8 @@ export function loadConfig(): AssistantConfig {
           // Same shape contract as `loadRawConfig`: top-level value must be a
           // plain object. A `null`, primitive, or array is treated like a
           // parse error so downstream code (`warnAndStripDeprecatedFields`,
-          // `setNestedValue` in the managed-Gemini migration block, etc.)
-          // never iterates a non-record. Quarantine + fall through to defaults.
+          // etc.) never iterates a non-record. Quarantine + fall through to
+          // defaults.
           quarantineCorruptConfig(
             configPath,
             new Error(
@@ -714,50 +723,14 @@ export function loadConfig(): AssistantConfig {
     }
 
     // Validate and apply defaults via Zod schema
-    let config = validateWithSchema(fileConfig);
+    const config = validateWithSchema(fileConfig);
 
-    if (suppressConfigDiskWritesDepth === 0) {
-      // Managed Gemini embedding defaults migration.
-      // When on a managed platform (IS_PLATFORM=true) and no explicit embedding
-      // provider chosen (provider=auto), persist Gemini embedding defaults into
-      // the raw config file.
-      // Idempotent: once provider=gemini is written, subsequent loads skip this.
-      if (config.memory.embeddings.provider === "auto") {
-        try {
-          if (
-            process.env.IS_PLATFORM === "true" ||
-            process.env.IS_PLATFORM === "1"
-          ) {
-            setNestedValue(fileConfig, "memory.embeddings.provider", "gemini");
-            setNestedValue(
-              fileConfig,
-              "memory.embeddings.geminiModel",
-              "gemini-embedding-2",
-            );
-            setNestedValue(
-              fileConfig,
-              "memory.embeddings.geminiDimensions",
-              3072,
-            );
-            setNestedValue(fileConfig, "memory.qdrant.vectorSize", 3072);
-            writeFileSync(
-              configPath,
-              JSON.stringify(fileConfig, null, 2) + "\n",
-            );
-            log.info(
-              "Applied managed Gemini embedding defaults (provider=gemini, model=gemini-embedding-2, dimensions=3072, vectorSize=3072)",
-            );
-            // Re-validate so the returned config reflects the migration.
-            config = validateWithSchema(fileConfig);
-          }
-        } catch (err) {
-          log.warn(
-            { err },
-            "Managed Gemini defaults migration failed — continuing with existing config",
-          );
-        }
-      }
-    }
+    // Snapshot the schema-defaulted config BEFORE deployment-context fills are
+    // layered on — but only when the first-launch seed below will actually
+    // persist it. Disk records user intent (schema defaults only), while the
+    // in-memory `config` returned below carries the deployment-context fills as
+    // this run's effective values.
+    const willSeed = !configFileExisted && suppressConfigDiskWritesDepth === 0;
 
     // Layer deployment-context defaults (e.g. IS_PLATFORM=true → all service
     // modes = "managed") onto the in-memory config for any leaves that aren't
@@ -778,29 +751,36 @@ export function loadConfig(): AssistantConfig {
       );
     }
 
-    // First-launch seed only: when config.json does not exist, write the full
-    // schema defaults (with any deployment-context overrides already applied
-    // above) to disk so users can discover and edit all available options.
+    // First-launch seed only: when config.json does not exist, write the
+    // effective config to disk so users can discover and edit all available
+    // options. Deployment-context service-mode defaults (e.g. IS_PLATFORM=true →
+    // managed service modes) are included for discoverability, but the platform
+    // embedding-provider intent is OMITTED entirely — not even persisted as the
+    // schema default "auto". `fillContextDefaultsForMissingKeys` only fills a
+    // leaf absent from disk, so persisting any provider value (including "auto")
+    // would be read back as an explicit user choice on the next load and
+    // permanently suppress re-applying the platform "gemini" default. Leaving
+    // the leaf absent keeps the platform intent in-memory-only yet re-applied on
+    // every load.
+    //
     // When the file already exists, leave it alone — disk represents user
     // intent, while the in-memory `cached: AssistantConfig` (above) has all
     // schema defaults applied via `applyNestedDefaults`/`validateWithSchema`,
     // so consumers calling `getConfig().memory.v2.bm25_b` continue to receive
-    // the schema default whenever the field is absent on disk.
-    //
-    // The previous behavior — eagerly merging missing keys back into the file
-    // on every load — silently baked stale defaults into existing users'
-    // config.json. Once a default landed in the file, future schema-default
-    // changes were inert because the merge only filled absent keys and never
-    // reconciled existing values. Contract: disk = user intent, in-memory
-    // cache = effective values.
-    if (!configFileExisted && suppressConfigDiskWritesDepth === 0) {
+    // the schema default whenever the field is absent on disk. Contract: disk =
+    // user intent, in-memory cache = effective values.
+    if (willSeed) {
       try {
         const dir = dirname(configPath);
         if (!existsSync(dir)) {
           mkdirSync(dir, { recursive: true });
         }
+        const seed = structuredClone(config);
+        // Drop the deployment-context embedding provider so it is never
+        // persisted (see above); the schema default re-applies in memory.
+        delete (seed.memory.embeddings as { provider?: unknown }).provider;
         // Strip dataDir (runtime-derived) from the persisted config
-        const { dataDir: _, ...persistable } = config;
+        const { dataDir: _, ...persistable } = seed;
         writeFileSync(configPath, JSON.stringify(persistable, null, 2) + "\n");
         log.info("Wrote default config to %s", configPath);
       } catch (err) {

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

@@ -9,3 +9,19 @@ import type { AssistantConfig } from "./schema.js";
 export function isMemoryV3Live(config: AssistantConfig): boolean {
   return config.memory?.v3?.live === true;
 }
+
+/**
+ * Whether procedural-memory-as-skills is ACTIVE: it is active whenever
+ * memory-v3 is the live injected source. The feature is scoped to v3-live
+ * assistants because skill retrieval rides the v3 lanes and the usage-prune
+ * stage lives in the v3 maintain job. That prune ships observe-first: with
+ * `memory.maintenance.skillPruneDays` at its default (`null`) it reports stale
+ * assistant-authored skills (`prunableSkills`) but deletes none — so a v3-live
+ * assistant authors skills without an automatic retirement bound until a
+ * positive `skillPruneDays` is configured. Gating the whole feature (the
+ * retrospective skill-authoring step and its permission grant) on this named
+ * predicate keeps it coherently inert on non-v3 assistants.
+ */
+export function isProcToSkillsActive(config: AssistantConfig): boolean {
+  return isMemoryV3Live(config);
+}

package/src/config/schema.ts

@@ -42,6 +42,7 @@ import {
 } from "./schemas/logging.js";
 import { McpConfigSchema } from "./schemas/mcp.js";
 import { MemoryConfigSchema } from "./schemas/memory.js";
+import { MigrationsConfigSchema } from "./schemas/migrations.js";
 import { NotificationsConfigSchema } from "./schemas/notifications.js";
 import {
   DaemonConfigSchema,
@@ -63,6 +64,7 @@ export const AssistantConfigSchema = z
   .object({
     services: ServicesSchema.default(ServicesSchema.parse({})),
     memory: MemoryConfigSchema.default(MemoryConfigSchema.parse({})),
+    migrations: MigrationsConfigSchema.default(MigrationsConfigSchema.parse({})),
     dataDir: z
       .string({ error: "dataDir must be a string" })
       .default(getDataDir())

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

@@ -22,8 +22,10 @@ describe("MemoryV3ConfigSchema", () => {
       needleK: 100,
       denseK: 100,
       replyQueryK: 12,
+      selectorEnabled: true,
       selectorPromptPath: null,
       edge: { hubDegree: 30, seedCount: 18, perSeed: 6, cap: 45 },
+      entity: { enabled: true, idfFloor: 4, cap: 8 },
     });
   });
 
@@ -85,10 +87,19 @@ describe("MemoryV3ConfigSchema", () => {
     ).toThrow();
   });
 
-  test("accepts explicit lane-K overrides", () => {
-    const parsed = MemoryV3ConfigSchema.parse({ needleK: 50, denseK: 75 });
-    expect(parsed.needleK).toBe(50);
+  test("accepts explicit lane-K overrides including zero", () => {
+    const parsed = MemoryV3ConfigSchema.parse({ needleK: 0, denseK: 75 });
+    expect(parsed.needleK).toBe(0);
     expect(parsed.denseK).toBe(75);
+
+    const zeroDense = MemoryV3ConfigSchema.parse({ needleK: 50, denseK: 0 });
+    expect(zeroDense.needleK).toBe(50);
+    expect(zeroDense.denseK).toBe(0);
+  });
+
+  test("accepts selector bypass override", () => {
+    const parsed = MemoryV3ConfigSchema.parse({ selectorEnabled: false });
+    expect(parsed.selectorEnabled).toBe(false);
   });
 
   test("accepts a partial edge override, defaulting the rest", () => {
@@ -101,9 +112,9 @@ describe("MemoryV3ConfigSchema", () => {
     });
   });
 
-  test("rejects non-positive or non-integer lane knobs", () => {
-    expect(() => MemoryV3ConfigSchema.parse({ needleK: 0 })).toThrow();
+  test("rejects negative or non-integer lane knobs", () => {
     expect(() => MemoryV3ConfigSchema.parse({ denseK: -4 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ needleK: -1 })).toThrow();
     expect(() => MemoryV3ConfigSchema.parse({ needleK: 1.5 })).toThrow();
     expect(() =>
       MemoryV3ConfigSchema.parse({ edge: { perSeed: 0 } }),

package/src/config/schemas/conversations.ts

@@ -20,6 +20,14 @@ export const ConversationsConfigSchema = z
       .describe(
         "Inner text injected into the tail user message of non-interactive turns in background/scheduled conversations. The injector wraps this in <background_turn>...</background_turn> tags. Empty string disables the injection.",
       ),
+    resumeProcessingOnStartup: z
+      .boolean({
+        error: "conversations.resumeProcessingOnStartup must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "Controls how conversations left mid-turn by a previous shutdown are handled on startup. When false (default), their stale processing flag is cleared so they come up idle. When true, the daemon will instead automatically resume the interrupted turn for each such conversation.",
+      ),
   })
   .describe("Conversation behavior configuration");
 

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

@@ -190,6 +190,15 @@ export const MemoryMaintenanceConfigSchema = z
       .describe(
         "Database maintenance is deferred unless at least this many milliseconds have elapsed since the last user message, so maintenance's write locks never collide with an active user (0 disables the quiet-period gate)",
       ),
+    skillPruneDays: z
+      .number({ error: "memory.maintenance.skillPruneDays must be a number" })
+      .int("memory.maintenance.skillPruneDays must be an integer")
+      .min(1, "memory.maintenance.skillPruneDays must be at least 1")
+      .nullable()
+      .default(null)
+      .describe(
+        'Usage-based prune threshold for assistant-authored skills, in days. `null` (the default) = never prune — the maintain stage runs observe-only and deletes nothing (it still reports stale skills for observability). Set a positive integer to enable deletion of assistant-authored skills unused (lastUsedAt, else installedAt) for at least that many days. Shipped default-off so skill accumulation can be observed before deletion is enabled. Only `author:"assistant"` skills are ever eligible; user-authored and untagged skills are always protected.',
+      ),
   })
   .describe(
     "Database maintenance (PRAGMA optimize / WAL checkpoint) scheduling",

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

@@ -48,10 +48,10 @@ export const MemoryV3HotSetSchema = z
     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")
+      .nonnegative("memory.v3.hotSet.k must be a non-negative integer")
       .default(40)
       .describe(
-        "Number of top frecency-scored pages included in the hot-set lane.",
+        "Number of top frecency-scored pages included in the hot-set lane. 0 disables the lane.",
       ),
     halfLifeDays: z
       .number({ error: "memory.v3.hotSet.halfLifeDays must be a number" })
@@ -214,10 +214,53 @@ export const MemoryV3PruneSchema = z
   })
   .describe("Memory v3 prune-valve (resident card footprint) bounds.");
 
+/**
+ * Entity-lane tuning: the heading-anchored named-entity match. A distinctive
+ * token the message shares with a `## ` section heading surfaces that section,
+ * so a named entity (person, place, project, product, bot) the additive needle
+ * buries under a long message's bulk theme is retrieved on the exact-name
+ * signal instead.
+ */
+export const MemoryV3EntitySchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "memory.v3.entity.enabled must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether the entity lane runs: surface the section whose `## ` heading names a distinctive entity the message mentions. Recall-additive and ~free when the message names no catalogued entity.",
+      ),
+    idfFloor: z
+      .number({ error: "memory.v3.entity.idfFloor must be a number" })
+      .nonnegative("memory.v3.entity.idfFloor must be a non-negative number")
+      .default(4)
+      .describe(
+        'Minimum corpus IDF for a `## ` heading token to become an entity key. Excludes hub tokens (e.g. "vellum") common enough that an exact match cannot disambiguate; those pages ride the core/hot lanes instead.',
+      ),
+    cap: z
+      .number({ error: "memory.v3.entity.cap must be a number" })
+      .int("memory.v3.entity.cap must be an integer")
+      .positive("memory.v3.entity.cap must be a positive integer")
+      .default(8)
+      .describe(
+        "Hard cap on the number of distinct entity-heading articles surfaced per turn.",
+      ),
+  })
+  .describe(
+    "Memory v3 entity-lane (heading-anchored named-entity match) tuning.",
+  );
+
 // 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()`.
+//
+// The retrieval tuning defaults across these sub-schemas (hotSet.k, freshSet.k,
+// learnedEdges.cap, edge.{seedCount,perSeed,cap}) and the top-level needleK /
+// denseK / replyQueryK / selectorEnabled are the FULL (established-corpus)
+// profile. Sparse-corpus assistants run the lean new-user profile
+// (`resolveV3Tuning` / `MEMORY_V3_NEW_USER_TUNING` in the v3 plugin's
+// `tuning-profile.ts`) until they cross `MEMORY_V3_FULL_PROFILE_MIN_PAGES` real
+// concept pages, at which point these configured values take effect.
 export const MemoryV3ConfigSchema = z
   .object({
     live: z
@@ -238,18 +281,18 @@ export const MemoryV3ConfigSchema = z
     needleK: z
       .number({ error: "memory.v3.needleK must be a number" })
       .int("memory.v3.needleK must be an integer")
-      .positive("memory.v3.needleK must be a positive integer")
+      .nonnegative("memory.v3.needleK must be a non-negative integer")
       .default(100)
       .describe(
-        "Number of section-grain BM25 needle articles folded into the candidate pool each turn.",
+        "Number of section-grain BM25 needle articles folded into the candidate pool each turn. 0 disables the needle lane.",
       ),
     denseK: z
       .number({ error: "memory.v3.denseK must be a number" })
       .int("memory.v3.denseK must be an integer")
-      .positive("memory.v3.denseK must be a positive integer")
+      .nonnegative("memory.v3.denseK must be a non-negative integer")
       .default(100)
       .describe(
-        "Number of dense-lane articles folded into the candidate pool each turn.",
+        "Number of dense-lane articles folded into the candidate pool each turn after embedding the turn query. 0 disables dense retrieval for both current-message and reply-query passes.",
       ),
     replyQueryK: z
       .number({ error: "memory.v3.replyQueryK must be a number" })
@@ -259,6 +302,12 @@ export const MemoryV3ConfigSchema = z
       .describe(
         "Per-lane article budget for the reply-query finder pass: needle and dense each re-run over the assistant's previous message as separate queries (never concatenated with the user's message). 0 disables the pass. Deliberately small next to needleK/denseK — the pass adds the assistant-side retrieval signal, not a second full sweep.",
       ),
+    selectorEnabled: z
+      .boolean({ error: "memory.v3.selectorEnabled must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether to run the memory-v3 selector LLM callsite over the candidate pool. When false, every pooled candidate is passed through to injection directly; an empty pool produces no memory block.",
+      ),
     selectorPromptPath: z
       .string({ error: "memory.v3.selectorPromptPath must be a string" })
       .nullable()
@@ -267,6 +316,7 @@ export const MemoryV3ConfigSchema = z
         "Optional path to a file whose contents replace the bundled per-turn selector system prompt (the instructions that tell the selector which candidate pages to keep). Absolute paths are used as-is, a leading `~/` is expanded to the home directory, otherwise the path is resolved under the workspace root. The selector prompt takes no placeholders — the candidate pool is supplied separately as the user message — so the file is used verbatim. If the file is missing, unreadable, empty, or over 1 MiB, the bundled prompt is used and a warning is logged.",
       ),
     edge: MemoryV3EdgeSchema.default(MemoryV3EdgeSchema.parse({})),
+    entity: MemoryV3EntitySchema.default(MemoryV3EntitySchema.parse({})),
   })
   .describe("Memory v3 — section-grain lane retrieval");
 

package/src/config/schemas/migrations.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+
+export const MigrationsWorkerConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "migrations.worker.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Enable the async migration worker. While false, migrations that are too expensive to run inside the synchronous startup migration runner skip their work and pass, deferring until the async runner is in place.",
+      ),
+  })
+  .describe("Async migration worker configuration");
+
+export const MigrationsConfigSchema = z
+  .object({
+    worker: MigrationsWorkerConfigSchema.default(
+      MigrationsWorkerConfigSchema.parse({}),
+    ),
+  })
+  .describe("Workspace/database migration configuration");
+
+export type MigrationsWorkerConfig = z.infer<
+  typeof MigrationsWorkerConfigSchema
+>;
+export type MigrationsConfig = z.infer<typeof MigrationsConfigSchema>;

package/src/config/schemas/services.ts

@@ -115,42 +115,6 @@ const HubspotOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 
-/**
- * `services.meet.host.*` — daemon-side knobs for the externalized meet-join
- * skill process. Kept narrow: only the values the daemon reads before the
- * meet-host child is spawned live here. Skill-internal configuration
- * (avatar renderer, consent copy, proactive-chat keywords, etc.) lives in
- * `skills/meet-join/config-schema.ts` and is sourced from the separate
- * `<workspace>/config/meet.json` file the skill owns.
- */
-const MeetHostConfigSchema = z
-  .object({
-    idle_timeout_ms: z
-      .number({
-        error: "services.meet.host.idle_timeout_ms must be a number",
-      })
-      .int()
-      .nonnegative()
-      .optional()
-      .describe(
-        "Idle window in milliseconds after the last active meet session closes before the meet-host child is shut down. Defaults to 5 minutes when unset.",
-      ),
-  })
-  .describe("Daemon-side configuration for the external meet-join skill host");
-
-/**
- * Daemon-side `services.meet` block. Intentionally distinct from the
- * skill-internal `MeetServiceSchema` in `skills/meet-join/config-schema.ts`,
- * which validates the bot-facing `<workspace>/config/meet.json` file. This
- * schema only describes the keys the assistant itself reads from its global
- * `config.json` before the meet-host child process is spawned.
- */
-const MeetDaemonServiceSchema = z
-  .object({
-    host: MeetHostConfigSchema.default(MeetHostConfigSchema.parse({})),
-  })
-  .describe("meet-join skill daemon-side configuration");
-
 export const ServicesSchema = z.object({
   inference: InferenceServiceSchema.default(InferenceServiceSchema.parse({})),
   "image-generation": ImageGenerationServiceSchema.default(
@@ -196,7 +160,6 @@ export const ServicesSchema = z.object({
   "hubspot-oauth": HubspotOAuthServiceSchema.default(
     HubspotOAuthServiceSchema.parse({}),
   ),
-  meet: MeetDaemonServiceSchema.default(MeetDaemonServiceSchema.parse({})),
 });
 export type Services = z.infer<typeof ServicesSchema>;