@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/memory/schema/infrastructure.ts

@@ -23,6 +23,7 @@ export const cronJobs = sqliteTable("cron_jobs", {
   maxRetries: integer("max_retries").notNull().default(3),
   retryBackoffMs: integer("retry_backoff_ms").notNull().default(60000),
   timeoutMs: integer("timeout_ms"), // script-mode execution timeout override (ms); null = use default
+  inferenceProfile: text("inference_profile"), // llm.profiles key for LLM-executed runs; null = default main-agent selection
   createdFromConversationId: text("created_from_conversation_id"),
   createdBy: text("created_by").notNull(), // 'agent' | 'user'
   mode: text("mode").notNull().default("execute"), // 'notify' | 'execute'
@@ -35,6 +36,9 @@ export const cronJobs = sqliteTable("cron_jobs", {
     .default(false), // reuse the same conversation across runs
   script: text("script"), // shell command for script mode (nullable, only used when mode = 'script')
   wakeConversationId: text("wake_conversation_id"), // target conversation for wake mode (nullable)
+  workflowName: text("workflow_name"), // saved workflow to trigger (nullable, only used when mode = 'workflow')
+  workflowArgsJson: text("workflow_args_json"), // JSON-encoded args passed to the workflow run (nullable)
+  capabilitiesJson: text("capabilities_json"), // JSON-encoded capability manifest for the run (nullable; null = hardcoded read-only manifest)
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),
 });

package/src/memory/schema/memory-core.ts

@@ -106,6 +106,10 @@ export const memoryRetrospectiveState = sqliteTable(
     conversationId: text("conversation_id").primaryKey(),
     lastProcessedMessageId: text("last_processed_message_id").notNull(),
     lastRunAt: integer("last_run_at").notNull(),
+    // JSON array of strings — cumulative `remember` contents from prior
+    // retrospective passes (capped; see memory-retrospective-state.ts).
+    // NULL for rows that predate migration 281 or have no saves yet.
+    rememberedLog: text("remembered_log"),
   },
 );
 

package/src/memory/v2/__tests__/concept-page-frontmatter-schema.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+
+import { ConceptPageFrontmatterSchema } from "../types.js";
+
+/**
+ * Regression: the frontmatter schema is `.passthrough()`, not `.strict()`.
+ *
+ * Migrated/converted corpora carry leaked source-page fields the article model
+ * does not define (`date`, `sources`, `world`, `outcome`, `as_of`, …). Under
+ * `.strict()` every such page threw in `readPage()` and was silently dropped
+ * from BOTH the page index and the section dense lane (a bulk deploy of
+ * summary-less wiki pages lost ~45% of them this way). `.passthrough()` keeps
+ * them on disk and in the index; the frontmatter sweep still surfaces malformed
+ * pages.
+ */
+describe("ConceptPageFrontmatterSchema", () => {
+  test("tolerates unknown frontmatter keys instead of throwing (passthrough)", () => {
+    const raw = {
+      summary: "A page about something.",
+      date: "2026-06-13",
+      sources: ["source-a", "source-b"],
+      world: "example-world",
+      outcome: "resolved",
+      as_of: "2026-06-13",
+    };
+    expect(() => ConceptPageFrontmatterSchema.parse(raw)).not.toThrow();
+    const parsed = ConceptPageFrontmatterSchema.parse(raw) as Record<
+      string,
+      unknown
+    >;
+    // Declared field is typed/kept...
+    expect(parsed.summary).toBe("A page about something.");
+    // ...and unknown keys pass through rather than being stripped or rejected.
+    expect(parsed.date).toBe("2026-06-13");
+    expect(parsed.sources).toEqual(["source-a", "source-b"]);
+    expect(parsed.outcome).toBe("resolved");
+  });
+
+  test("still applies declared-field defaults", () => {
+    const parsed = ConceptPageFrontmatterSchema.parse({});
+    expect(parsed.edges).toEqual([]);
+    expect(parsed.ref_files).toEqual([]);
+    expect(parsed.ref_urls).toEqual([]);
+  });
+});

package/src/memory/v2/__tests__/frontmatter-sweep.test.ts

@@ -4,8 +4,8 @@
  * Coverage:
  *   - v2 disabled → returns early, no warns, no throw.
  *   - Empty workspace → no warns, no throw.
- *   - One bad page (unknown frontmatter key) → exactly one warn carrying
- *     `errCode: "unrecognized_keys"` and the offending slug.
+ *   - One bad page (malformed frontmatter — wrong type on a declared field) →
+ *     exactly one warn carrying `errCode: "invalid_type"` and the offending slug.
  *   - Two bad + one good page → two warns; good page produces nothing.
  *   - Malformed YAML → a warn surfaces; the sweep does not crash.
  */
@@ -59,7 +59,11 @@ function makeWorkspace(pages: Record<string, string>): string {
 }
 
 const goodPage = `---\nedges: []\nref_files: []\n---\nbody\n`;
-const badPage = `---\nedges: []\nref_files: []\nbogus_field: 1\n---\nbody\n`;
+// Malformed: `edges` is a declared `z.array(z.string())` field, so a scalar
+// value fails the schema with `invalid_type`. (An *unknown* key would NOT be
+// bad — the schema is `.passthrough()`, so unknown keys are tolerated; the
+// sweep only surfaces genuinely malformed pages that `readPage` would throw on.)
+const badPage = `---\nedges: not-a-list\nref_files: []\n---\nbody\n`;
 
 describe("sweepConceptPageFrontmatter", () => {
   beforeEach(() => {
@@ -86,14 +90,14 @@ describe("sweepConceptPageFrontmatter", () => {
     }
   });
 
-  test("one bad page emits exactly one unrecognized_keys warn", async () => {
+  test("one bad page emits exactly one invalid_type warn", async () => {
     const dir = makeWorkspace({ "bad-one": badPage });
     try {
       await sweepConceptPageFrontmatter(v2On, dir);
       expect(warnCalls).toHaveLength(1);
       expect(warnCalls[0].data.slug).toBe("bad-one");
-      expect(warnCalls[0].data.errCode).toBe("unrecognized_keys");
-      expect(warnCalls[0].data.errKeys).toEqual(["bogus_field"]);
+      expect(warnCalls[0].data.errCode).toBe("invalid_type");
+      expect(warnCalls[0].data.errPath).toEqual(["edges"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -110,7 +114,7 @@ describe("sweepConceptPageFrontmatter", () => {
       const slugs = warnCalls.map((c) => c.data.slug).sort();
       expect(slugs).toEqual(["bad-a", "bad-b"]);
       for (const call of warnCalls) {
-        expect(call.data.errCode).toBe("unrecognized_keys");
+        expect(call.data.errCode).toBe("invalid_type");
       }
     } finally {
       rmSync(dir, { recursive: true, force: true });

package/src/memory/v2/__tests__/page-store.test.ts

@@ -293,7 +293,11 @@ describe("writePage + readPage round-trip", () => {
     expect(read!.body).toBe(body);
   });
 
-  test("readPage throws on unknown frontmatter keys instead of silently dropping them", async () => {
+  test("readPage tolerates unknown frontmatter keys and passes them through", async () => {
+    // The schema is `.passthrough()`, not `.strict()`: migrated/converted
+    // corpora carry leaked source-page fields the article model doesn't define.
+    // Unknown keys must pass through and stay on disk (loss-proof) rather than
+    // throwing and silently dropping the page from the index.
     const slug = "extra-keys";
     const raw =
       "---\nedges: []\nref_files: []\nunknown_field: oops\n---\nbody\n";
@@ -303,7 +307,14 @@ describe("writePage + readPage round-trip", () => {
       "utf-8",
     );
 
-    await expect(readPage(workspaceDir, slug)).rejects.toThrow();
+    const read = await readPage(workspaceDir, slug);
+    expect(read).not.toBeNull();
+    expect(read!.frontmatter.edges).toEqual([]);
+    // Unknown key survives the round-trip instead of being rejected or stripped.
+    expect((read!.frontmatter as Record<string, unknown>).unknown_field).toBe(
+      "oops",
+    );
+    expect(read!.body).toBe("body\n");
   });
 
   test("writePage overwrites an existing page", async () => {

package/src/memory/v2/__tests__/qdrant.test.ts

@@ -377,6 +377,30 @@ describe("memory v2 qdrant — collection lifecycle", () => {
     expect(params.sparse_vectors.summary_sparse).toBeDefined();
   });
 
+  test("detects a wrong-dimension dense vector on an existing collection and recreates", async () => {
+    // All required named vectors PRESENT, but the dense channels are sized to a
+    // different embedding dimension than the configured 384 (e.g. a 768-dim
+    // collection from a prior embedding model). Every upsert would fail with
+    // HTTP 400 until the collection is recreated — the missing-vector check
+    // alone never catches this.
+    state.collectionExistsBeforeCreate = true;
+    state.getCollectionInfo = {
+      config: {
+        params: {
+          vectors: { dense: { size: 768 }, summary_dense: { size: 768 } },
+          sparse_vectors: { sparse: {}, summary_sparse: {} },
+        },
+      },
+    };
+
+    const result = await ensureConceptPageCollection();
+
+    expect(state.getCollectionCalls).toBe(1);
+    expect(state.deleteCollectionCalls).toEqual([MEMORY_V2_COLLECTION]);
+    expect(state.createCollectionCalls).toBe(1);
+    expect(result).toEqual({ migrated: true });
+  });
+
   test("leaves a fully migrated collection untouched", async () => {
     // Default `getCollectionInfo` is FULL_SCHEMA_INFO — already migrated.
     state.collectionExistsBeforeCreate = true;

package/src/memory/v2/frontmatter-sweep.ts

@@ -3,12 +3,13 @@
 // ---------------------------------------------------------------------------
 //
 // At daemon startup, walk every concept page on disk and validate its
-// frontmatter against `ConceptPageFrontmatterSchema` (which is `.strict()`).
-// Schema-drifted pages — e.g. a user-authored file that adds a frontmatter
-// key the schema doesn't allow — would otherwise stay invisible until the
-// page lands in a conversation's top-K and `renderInjectionBlock`'s
-// `Promise.all` rejects, silently no-op'ing V2 dynamic injection for the
-// whole turn. Surfacing them as `warn` log lines at boot turns that into a
+// frontmatter against `ConceptPageFrontmatterSchema`. The schema is
+// `.passthrough()`, so unknown keys are tolerated; what this sweep catches is
+// genuinely malformed frontmatter — a wrong type on a declared field, or YAML
+// that doesn't parse. Such pages would otherwise stay invisible until one lands
+// in a conversation's top-K and `renderInjectionBlock`'s `Promise.all` rejects
+// (readPage throws), silently no-op'ing V2 dynamic injection for the whole
+// turn. Surfacing them as `warn` log lines at boot turns that into a
 // debuggable signal.
 //
 // This sweep is intentionally separate from `rebuildConceptPageCorpusStats`:

package/src/memory/v2/page-store.ts

@@ -192,9 +192,10 @@ export function slugFromConceptPath(
 /**
  * Split raw file contents into (frontmatter, body). If no frontmatter block
  * is present the entire input is treated as body and an empty frontmatter
- * block is returned (validated by `ConceptPageFrontmatterSchema` so any
- * unexpected shape — bad types, extra junk — surfaces as a parse error to
- * the caller, not silent dropped data).
+ * block is returned (validated by `ConceptPageFrontmatterSchema` so a bad
+ * type on a declared field surfaces as a parse error to the caller, not
+ * silently dropped data). The schema is `.passthrough()`, so unknown keys are
+ * kept rather than rejected — migrated corpora carry leaked source-page fields.
  *
  * The schema's defaults guarantee `edges` and `ref_files` are always arrays
  * even on freshly created pages with empty frontmatter.

package/src/memory/v2/qdrant.ts

@@ -199,7 +199,8 @@ async function ensureConceptPageCollectionOnce(): Promise<{
       }
 
       const missing = missingNamedVectors(info);
-      if (missing.length === 0) {
+      const wrongSize = wrongSizeNamedVectors(info, vectorSize);
+      if (missing.length === 0 && wrongSize.length === 0) {
         // Long-lived installs may predate the `kind` payload index; ensure
         // every required index exists before declaring the collection ready.
         await ensurePayloadIndexes();
@@ -208,8 +209,12 @@ async function ensureConceptPageCollectionOnce(): Promise<{
       }
 
       log.warn(
-        { collection: MEMORY_V2_COLLECTION, missingNamedVectors: missing },
-        "Memory v2 concept-page collection schema drift detected — deleting and recreating; embeddings will be regenerated by background reembed",
+        {
+          collection: MEMORY_V2_COLLECTION,
+          missingNamedVectors: missing,
+          wrongSizeNamedVectors: wrongSize,
+        },
+        "Memory v2 concept-page collection schema/dimension drift detected — deleting and recreating; embeddings will be regenerated by background reembed",
       );
       // Persist the reembed intent BEFORE the destructive delete so a crash
       // (or transient createCollection failure) between delete and recreate
@@ -366,6 +371,40 @@ function missingNamedVectors(
   return missing;
 }
 
+/**
+ * Return the names of required dense named vectors that are PRESENT but sized
+ * to a different dimension than `expectedSize`. A collection created under a
+ * different embedding model (e.g. a 384-dim collection now serving a 3072-dim
+ * embedder) has all its named vectors but at the wrong dimension — every upsert
+ * then fails with HTTP 400, and the {@link missingNamedVectors} check alone
+ * never detects it. Combined with that check, this triggers the same
+ * destructive recreate + reembed path.
+ *
+ * Only dense vectors carry an explicit `size`; sparse vectors are dimensionless
+ * and are not checked. A single unnamed-vector shape (top-level `size`) or an
+ * unparseable response returns `[]`.
+ */
+function wrongSizeNamedVectors(
+  info: Awaited<ReturnType<QdrantRestClient["getCollection"]>>,
+  expectedSize: number,
+): string[] {
+  const dense = info.config?.params?.vectors;
+  // Named-vectors map only — mirror the `!("size" in dense)` guard in
+  // `missingNamedVectors`. A single unnamed vector exposes `size` at the top
+  // level; its dimension is the collection's and is handled by the caller.
+  if (!dense || typeof dense !== "object" || "size" in dense) return [];
+  const map = dense as Record<string, unknown>;
+  const wrong: string[] = [];
+  for (const name of REQUIRED_DENSE_VECTORS) {
+    const entry = map[name];
+    if (entry && typeof entry === "object" && "size" in entry) {
+      const size = (entry as { size?: unknown }).size;
+      if (typeof size === "number" && size !== expectedSize) wrong.push(name);
+    }
+  }
+  return wrong;
+}
+
 /**
  * Upsert a concept page's dense + sparse embedding. The point ID is derived
  * deterministically from the slug so subsequent calls for the same slug

package/src/memory/v2/types.ts

@@ -42,17 +42,15 @@ export const ConceptPageFrontmatterSchema = z
     summary: z.string().optional(),
     leaves: z.array(z.string()).optional(),
     // Optional authored `"<target-slug> — <why>"` cross-links. Curated, first-class
-    // edges for the memory-v3 edge lane. Declared here so `.strict()` does not
-    // reject a page that uses `links:`, and so `renderPageContent` round-trips the
-    // field (the edge graph reads it back from the rendered frontmatter).
+    // edges for the memory-v3 edge lane. Declared (rather than left to the
+    // `.passthrough()` catchall below) so it carries a real type and so
+    // `renderPageContent` round-trips the field (the edge graph reads it back
+    // from the rendered frontmatter).
     links: z.array(z.string()).optional(),
     // The memory-v3 wiki-article fields — the shape CONSOLIDATION_PROMPT_V3
-    // teaches and migrated corpora arrive in. Declared for the same two
-    // reasons as `links:`: `.strict()` must not reject them (readPage()
-    // THROWS on schema failure, and a single invalid page in a turn's top-K
-    // no-ops the entire v2 injection block — see frontmatter-sweep.ts), and
-    // `renderPageContent` must round-trip them (a programmatic rewrite must
-    // not strip a page's `status:` draft marker or its display `title`).
+    // teaches and migrated corpora arrive in. Declared (not just tolerated by
+    // the catchall) so `renderPageContent` round-trips them — a programmatic
+    // rewrite must not strip a page's `status:` draft marker or `title`.
     // `kind` and `status` stay free-form strings: their known values today
     // ("index", "cc-draft") are conventions of the article model, not
     // invariants this storage layer should enforce.
@@ -68,7 +66,15 @@ export const ConceptPageFrontmatterSchema = z
     // from `status:` (the article-model draft marker, e.g. "cc-draft").
     current: z.string().optional(),
   })
-  .strict();
+  // `.passthrough()`, NOT `.strict()`: tolerate unknown frontmatter keys instead
+  // of throwing. Migrated/converted corpora carry leaked source-page fields the
+  // article model does not define (`date`, `sources`, `world`, `outcome`,
+  // `as_of`, …). Under `.strict()` every such page failed `readPage()` and was
+  // silently dropped from BOTH the page index and the section dense lane — a far
+  // worse failure than the schema drift strictness guarded against (a bulk
+  // wiki deploy lost ~45% of pages this way). Unknown keys pass through and stay
+  // on disk (loss-proof); the frontmatter sweep still surfaces malformed pages.
+  .passthrough();
 
 export type ConceptPageFrontmatter = z.infer<
   typeof ConceptPageFrontmatterSchema

package/src/messaging/draft-store.ts

@@ -1,7 +1,7 @@
 /**
  * Local draft storage for messaging.
  *
- * Stores drafts at ~/.vellum/workspace/data/drafts/<platform>/<id>.json
+ * Stores drafts at $VELLUM_WORKSPACE_DIR/data/drafts/<platform>/<id>.json
  * Works across all platforms — Slack, Gmail, Discord, etc.
  */