@vellumai/assistant 0.10.4-dev.202607010028.1a4efcc → 0.10.4-dev.202607010146.a37a2fa

package/Dockerfile

@@ -24,7 +24,6 @@ COPY packages/egress-proxy ./packages/egress-proxy
 COPY packages/environments ./packages/environments
 COPY packages/gateway-client ./packages/gateway-client
 COPY packages/ipc-server-utils ./packages/ipc-server-utils
-COPY packages/skill-host-contracts ./packages/skill-host-contracts
 COPY packages/slack-text ./packages/slack-text
 COPY packages/twilio-client ./packages/twilio-client
 

package/eslint-rules/cli-no-daemon-internals.js

@@ -21,6 +21,10 @@ const ALLOWED_PREFIXES = {
     // Status command's daemon-down fallback needs socket path + platform.
     "../../ipc/socket-path",
     "../../util/platform",
+    // App version constant (leaf module; reads package.json/env, no daemon
+    // deps) — status prints it to surface CLI-vs-runtime version drift.
+    "../../version",
+    "../../../version",
     // Logger / output at depth-1 and depth-2.
     "../logger",
     "../output",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607010028.1a4efcc",
+  "version": "0.10.4-dev.202607010146.a37a2fa",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-queue.test.ts

@@ -827,6 +827,13 @@ describe("Conversation message queue", () => {
       (e) => e.type === "conversation_error",
     );
     expect(conversationErr3).toBeUndefined();
+
+    // Settle the aborted in-flight run so its abort watchdog clears the
+    // real-time timer it armed. A leaked ~5s timer otherwise fires during a
+    // later test and drives this stale turn into commitTurnChanges, inflating
+    // the shared turnCommitCalls counter that other tests assert against.
+    await resolveRun(0);
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("conversation-scoped errors emit both conversation_error and generic error", async () => {
@@ -2801,6 +2808,13 @@ describe("Regression: cancel semantics and error channel split", () => {
       );
       expect(conversationErr).toBeUndefined();
     }
+
+    // Settle the aborted in-flight run so its abort watchdog clears the
+    // real-time timer it armed. A leaked ~5s timer otherwise fires during a
+    // later test and drives this stale turn into commitTurnChanges, inflating
+    // the shared turnCommitCalls counter that other tests assert against.
+    await resolveRun(0);
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("commitTurnChanges never resolving within budget -> turn still completes and drains queue", async () => {

package/src/__tests__/persistence-layering-guard.test.ts

@@ -37,22 +37,16 @@ const MEMORY_DIR = join(ASSISTANT_SRC, "plugins", "defaults", "memory");
  * TECH DEBT — residual `persistence/` → `memory/` feature back-imports.
  *
  * A genuine coupling to the memory *feature* that violates the one-way
- * memory → persistence direction, pinned here so the guard fails the moment a
- * NEW back-import is introduced.
- *
- * The lone remaining entry is the in-worker memory consolidation /
- * graph-maintenance SCHEDULER (`jobs-worker.ts` → `v2/consolidation-job` for
- * `countBufferLines`). Inverting it means memory deciding what to enqueue on
- * each worker tick — that is roadmap bullet #4 (memory-jobs → schedule-jobs),
- * deferred until the Schedules worker + `/workspace/schedules` API land.
- * Decouple it then; do not add to this list without a decoupling plan.
+ * memory → persistence direction would be pinned here so the guard fails the
+ * moment a NEW back-import is introduced. It is currently EMPTY: persistence
+ * reaches the memory feature only through the `memory-lifecycle-hooks` seam
+ * (persistence calls registered handlers; memory never gets imported), never by
+ * importing memory internals. Do not add an entry without a decoupling plan.
  *
  * Keyed by the importing persistence file (relative to repo root); the value
  * is the set of allowed `memory/<specifier>` module paths it may import.
  */
-const PERSISTENCE_TO_MEMORY_ALLOWLIST: Record<string, ReadonlySet<string>> = {
-  "assistant/src/persistence/jobs-worker.ts": new Set(["v2/consolidation-job"]),
-};
+const PERSISTENCE_TO_MEMORY_ALLOWLIST: Record<string, ReadonlySet<string>> = {};
 
 /**
  * PERMANENT exception — the migration registry, NOT tech debt.

package/src/__tests__/plugin-disabled-state.test.ts

@@ -261,6 +261,7 @@ describe("per-surface disabled-state filtering", () => {
 
   test("persistence hooks no-op while the memory plugin is disabled", async () => {
     let calls = 0;
+    const bufferLines = 25;
     const guarded = guardPersistenceHooksByDisabledState("default-memory", {
       onMessagePersisted() {
         calls++;
@@ -270,6 +271,9 @@ describe("per-surface disabled-state filtering", () => {
         return 0;
       },
       onWorkerStartup() {},
+      countMemoryBufferLines() {
+        return bufferLines;
+      },
     });
     const event: MessagePersistedEvent = {
       messageId: "msg-1",
@@ -282,16 +286,21 @@ describe("per-surface disabled-state filtering", () => {
     // Enabled: the wrapped handler runs.
     await guarded.onMessagePersisted(event);
     expect(calls).toBe(1);
+    // The gated query returns the real buffer count while enabled.
+    expect(guarded.countMemoryBufferLines()).toBe(25);
 
     // Disable via sentinel — checked at call time, no restart needed.
     await createSentinel("default-memory");
     await guarded.onMessagePersisted(event);
     expect(calls).toBe(1);
+    // Gated: reports an empty buffer while disabled, so consolidation stays inert.
+    expect(guarded.countMemoryBufferLines()).toBe(0);
 
     // Re-enable.
     await removeSentinel("default-memory");
     await guarded.onMessagePersisted(event);
     expect(calls).toBe(2);
+    expect(guarded.countMemoryBufferLines()).toBe(25);
   });
 
   test("cleanup persistence hooks run even while the memory plugin is disabled", async () => {
@@ -307,6 +316,9 @@ describe("per-surface disabled-state filtering", () => {
       onWorkerStartup() {
         swept++;
       },
+      countMemoryBufferLines() {
+        return 0;
+      },
     });
 
     await createSentinel("default-memory");

package/src/__tests__/skill-tool-factory.test.ts

@@ -334,13 +334,65 @@ describe("createSkillTool — required/type/enum validation", () => {
       BUNDLED,
     );
 
-    const result = await tool.execute({ query: 123 }, makeContext());
+    const result = await tool.execute({ query: { nested: 1 } }, makeContext());
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('Invalid input for tool "test_tool"');
     expect(result.content).toContain("query must be a string");
   });
 
+  test("coerces finite numbers to strings before validation and passes the coerced value to the executor", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({
+        executor: "echo.ts",
+        input_schema: {
+          type: "object",
+          properties: { phone_number: { type: "string" } },
+          required: ["phone_number"],
+        },
+      }),
+      tempDir,
+      hash,
+      BUNDLED,
+    );
+
+    const result = await tool.execute(
+      { phone_number: 15550100 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.input).toEqual({ phone_number: "15550100" });
+  });
+
+  test("rejects integers outside the safe range instead of coercing a rounded value", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({
+        executor: "echo.ts",
+        input_schema: {
+          type: "object",
+          properties: { account_id: { type: "string" } },
+          required: ["account_id"],
+        },
+      }),
+      tempDir,
+      hash,
+      BUNDLED,
+    );
+
+    const result = await tool.execute(
+      { account_id: 12345678901234567890 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "test_tool"');
+    expect(result.content).toContain("account_id must be a string");
+  });
+
   test("rejects enum violation with `must be one of` message", async () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(

package/src/cli/commands/__tests__/status.test.ts

@@ -51,6 +51,12 @@ mock.module("../../../util/platform.js", () => ({
   getWorkspaceDirDisplay: () => "~/.vellum/workspace",
 }));
 
+// Fixed installed CLI version so drift-vs-match is deterministic.
+const INSTALLED_CLI_VERSION = "9.9.9";
+mock.module("../../../version.js", () => ({
+  APP_VERSION: INSTALLED_CLI_VERSION,
+}));
+
 mock.module("../../../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -182,13 +188,13 @@ describe("status command — daemon unreachable (ENOENT/ECONNREFUSED)", () => {
     expect(stdout).toContain("Assistant: running");
   });
 
-  test("does not print version or memory when daemon is unreachable", async () => {
+  test("prints the installed CLI version but no runtime health when unreachable", async () => {
     mockResponse = { ok: false, error: DAEMON_UNREACHABLE_ERROR };
     socketExists = false;
 
     const { stdout, stderr } = await runStatusCommand();
 
-    expect(stdout + stderr).not.toContain("Version");
+    expect(stdout).toContain(`CLI Version: ${INSTALLED_CLI_VERSION}`);
     expect(stdout + stderr).not.toContain("Memory");
   });
 });
@@ -242,8 +248,42 @@ describe("status command — daemon up", () => {
     const { stdout, stderr } = await runStatusCommand();
     const combined = stdout + stderr;
 
+    expect(combined).toContain("Assistant Version");
     expect(combined).toContain("1.2.3");
     expect(combined).toContain("100");
     expect(combined).toContain("500");
   });
+
+  test("flags the runtime as stale when it differs from the installed CLI", async () => {
+    mockResponse = {
+      ok: true,
+      result: {
+        version: "1.2.3",
+        memory: { currentMb: 100, maxMb: 500 },
+        disk: null,
+      },
+    };
+
+    const { stdout } = await runStatusCommand();
+
+    expect(stdout).toContain(
+      `1.2.3 (stale — restart to run ${INSTALLED_CLI_VERSION})`,
+    );
+  });
+
+  test("shows a bare version with no stale note when versions match", async () => {
+    mockResponse = {
+      ok: true,
+      result: {
+        version: INSTALLED_CLI_VERSION,
+        memory: { currentMb: 100, maxMb: 500 },
+        disk: null,
+      },
+    };
+
+    const { stdout } = await runStatusCommand();
+
+    expect(stdout).toContain(`Assistant Version  ${INSTALLED_CLI_VERSION}`);
+    expect(stdout).not.toContain("stale");
+  });
 });

package/src/cli/commands/status.ts

@@ -5,6 +5,7 @@ import type { Command } from "commander";
 import { cliIpcCall } from "../../ipc/cli-client.js";
 import { getAssistantSocketPath } from "../../ipc/socket-path.js";
 import { getWorkspaceDirDisplay } from "../../util/platform.js";
+import { APP_VERSION } from "../../version.js";
 import { registerCommand } from "../lib/register-command.js";
 
 interface HealthResponse {
@@ -34,6 +35,9 @@ export function registerStatusCommand(program: Command): void {
             const socketPath = getAssistantSocketPath();
             const socketExists = existsSync(socketPath);
             const workspace = getWorkspaceDirDisplay();
+            // Daemon unreachable, so its runtime version is unknown; show the
+            // installed CLI version so there's always one reliable number.
+            process.stdout.write(`CLI Version: ${APP_VERSION}\n`);
             process.stdout.write(
               (socketExists ? "Assistant: running" : "Assistant: down") + "\n",
             );
@@ -52,8 +56,15 @@ export function registerStatusCommand(program: Command): void {
         const h = result.result;
         const workspace = getWorkspaceDirDisplay();
 
+        // h.version is the running runtime; APP_VERSION is the installed CLI.
+        // They drift mid-upgrade (CLI bumped, daemon not yet restarted).
+        const runtimeVersion =
+          h.version === APP_VERSION
+            ? h.version
+            : `${h.version} (stale — restart to run ${APP_VERSION})`;
+
         const rows: [string, string][] = [
-          ["Version", h.version],
+          ["Assistant Version", runtimeVersion],
           ["Workspace", workspace],
           ["", ""],
           ["Memory", `${fmtMb(h.memory.currentMb)} / ${fmtMb(h.memory.maxMb)}`],

package/src/config/__tests__/messages-search-backend.test.ts

@@ -0,0 +1,77 @@
+import { afterAll, afterEach, describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+afterAll(() => {
+  mock.restore();
+});
+
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+import { getMessagesSearchBackend } from "../assistant-feature-flags.js";
+import type { AssistantConfig } from "../schema.js";
+
+// The resolver reads the flag from the override cache + registry; it does not
+// consult the passed config, so a minimal stub is sufficient.
+const CONFIG = {} as AssistantConfig;
+
+describe("getMessagesSearchBackend", () => {
+  afterEach(() => {
+    setOverridesForTesting({});
+  });
+
+  // Each case seeds the override cache so the value flows through the real
+  // `getAssistantFeatureFlagValue` plumbing. The flag is boolean, so enabled
+  // (`true`) selects qdrant and disabled/unset falls back to fts5. The string
+  // cases are defensive: the override plumbing is typed `boolean | string`, so
+  // a stray string could still arrive — only the exact `"qdrant"` selects
+  // qdrant; every other value falls back to the safe fts5 default.
+
+  test("defaults to fts5 when the flag is unset", () => {
+    setOverridesForTesting({});
+    expect(getMessagesSearchBackend(CONFIG)).toBe("fts5");
+  });
+
+  test("returns qdrant when the flag is enabled (boolean true)", () => {
+    setOverridesForTesting({ "messages-search-backend": true });
+    expect(getMessagesSearchBackend(CONFIG)).toBe("qdrant");
+  });
+
+  test("returns fts5 when the flag is disabled (boolean false)", () => {
+    setOverridesForTesting({ "messages-search-backend": false });
+    expect(getMessagesSearchBackend(CONFIG)).toBe("fts5");
+  });
+
+  test('defensively selects qdrant for a stray string "qdrant" override', () => {
+    setOverridesForTesting({ "messages-search-backend": "qdrant" });
+    expect(getMessagesSearchBackend(CONFIG)).toBe("qdrant");
+  });
+
+  test('defensively falls back to fts5 for a stray string "fts5" override', () => {
+    setOverridesForTesting({ "messages-search-backend": "fts5" });
+    expect(getMessagesSearchBackend(CONFIG)).toBe("fts5");
+  });
+
+  test("defensively falls back to fts5 for an unexpected non-empty string", () => {
+    setOverridesForTesting({ "messages-search-backend": "bogus" });
+    expect(getMessagesSearchBackend(CONFIG)).toBe("fts5");
+  });
+});

package/src/config/assistant-feature-flags.ts

@@ -326,3 +326,25 @@ export function isAssistantFeatureFlagEnabled(
 ): boolean {
   return !!getAssistantFeatureFlagValue(key, config);
 }
+
+/**
+ * Backends that resolve lexical message-content search.
+ *   fts5   — SQLite FTS5 full-text index (default)
+ *   qdrant — BM25-style sparse Qdrant lexical index (messages_lexical)
+ */
+export type MessagesSearchBackend = "fts5" | "qdrant";
+
+/**
+ * Resolve the active messages search backend from the boolean
+ * `messages-search-backend` flag. Disabled (default) ⇒ `fts5`; enabled
+ * (boolean `true`) ⇒ `qdrant`. The raw comparison also treats a stray
+ * string override of `"qdrant"` as enabled; every other value (`false`,
+ * `"fts5"`, any other string, undefined) falls back to `fts5` so the safe
+ * default always wins for an unexpected override.
+ */
+export function getMessagesSearchBackend(
+  config: AssistantConfig,
+): MessagesSearchBackend {
+  const raw = getAssistantFeatureFlagValue("messages-search-backend", config);
+  return raw === "qdrant" || raw === true ? "qdrant" : "fts5";
+}

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

@@ -409,6 +409,14 @@
       "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
+    },
+    {
+      "id": "messages-search-backend",
+      "scope": "assistant",
+      "key": "messages-search-backend",
+      "label": "Messages Search Backend",
+      "description": "When disabled (default), message content search uses SQLite FTS5. When enabled, it uses the sparse Qdrant lexical index.",
+      "defaultEnabled": false
     }
   ]
 }

package/src/persistence/__tests__/conversation-search-lexical.test.ts

@@ -0,0 +1,103 @@
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+import type { SparseEmbedding } from "../embeddings/embedding-types.js";
+import type { MessageLexicalSearchResult } from "../embeddings/messages-lexical-index.js";
+
+const SPARSE: SparseEmbedding = { indices: [1, 2, 3], values: [0.5, 0.5, 0.5] };
+const EMPTY_SPARSE: SparseEmbedding = { indices: [], values: [] };
+
+// Mirror the real encoder: input that tokenizes to nothing (only whitespace
+// or punctuation) yields an empty sparse vector.
+const generateSparseEmbeddingMock = mock(
+  (text: string): SparseEmbedding =>
+    /[\p{L}\p{N}]/u.test(text) ? SPARSE : EMPTY_SPARSE,
+);
+
+const searchLexicalMock = mock(
+  async (
+    _sparse: SparseEmbedding,
+    _limit: number,
+    _opts?: { conversationId?: string },
+  ): Promise<MessageLexicalSearchResult[]> => [
+    { messageId: "msg-1", score: 0.9 },
+    { messageId: "msg-2", score: 0.4 },
+  ],
+);
+
+const getMessagesLexicalIndexMock = mock(() => ({
+  searchLexical: searchLexicalMock,
+}));
+
+// `embedding-backend` is mocked WITHOUT spreading the real module: importing
+// it transitively pulls provider/security modules (and `packages/service-
+// contracts` → `zod`) into the test for no benefit. The helper only imports
+// `generateSparseEmbedding`, so a targeted replacement is complete for this
+// file's needs.
+mock.module("../embeddings/embedding-backend.js", () => ({
+  generateSparseEmbedding: generateSparseEmbeddingMock,
+}));
+
+// `messages-lexical-index` IS spread from the real module. Bun's
+// `mock.module` is process-global and is not undone by `mock.restore()`, so a
+// partial replacement would drop the module's other real exports
+// (`messagePointId`, `initMessagesLexicalIndex`, `MessagesLexicalIndex`, …)
+// for any test that runs later in the same process (e.g.
+// `embeddings/__tests__/messages-lexical-index.test.ts`, which imports
+// `messagePointId`). Spreading keeps those intact; its deps
+// (`@qdrant/js-client-rest`, `uuid`) are installed, so importing it is safe.
+const actualLexicalIndex =
+  await import("../embeddings/messages-lexical-index.js");
+mock.module("../embeddings/messages-lexical-index.js", () => ({
+  ...actualLexicalIndex,
+  getMessagesLexicalIndex: getMessagesLexicalIndexMock,
+}));
+
+const { searchMessageIdsLexical } =
+  await import("../conversation-search-lexical.js");
+
+afterAll(() => {
+  mock.restore();
+});
+
+describe("searchMessageIdsLexical", () => {
+  test("encodes the query and returns the index results", async () => {
+    generateSparseEmbeddingMock.mockClear();
+    searchLexicalMock.mockClear();
+
+    const results = await searchMessageIdsLexical("hello world", 5);
+
+    expect(generateSparseEmbeddingMock).toHaveBeenCalledTimes(1);
+    expect(generateSparseEmbeddingMock.mock.calls[0]).toEqual(["hello world"]);
+
+    // The encoded sparse vector and limit are passed straight through.
+    expect(searchLexicalMock).toHaveBeenCalledTimes(1);
+    expect(searchLexicalMock.mock.calls[0]![0]).toBe(SPARSE);
+    expect(searchLexicalMock.mock.calls[0]![1]).toBe(5);
+
+    expect(results).toEqual([
+      { messageId: "msg-1", score: 0.9 },
+      { messageId: "msg-2", score: 0.4 },
+    ]);
+  });
+
+  test("passes conversationId through to the index", async () => {
+    searchLexicalMock.mockClear();
+
+    await searchMessageIdsLexical("scoped", 3, { conversationId: "conv-xyz" });
+
+    expect(searchLexicalMock).toHaveBeenCalledTimes(1);
+    expect(searchLexicalMock.mock.calls[0]![2]).toEqual({
+      conversationId: "conv-xyz",
+    });
+  });
+
+  test("returns [] without querying the index for an empty-after-tokenize query", async () => {
+    searchLexicalMock.mockClear();
+
+    const results = await searchMessageIdsLexical("   ... !!! ", 5);
+
+    expect(results).toEqual([]);
+    // The empty sparse vector must never reach Qdrant.
+    expect(searchLexicalMock).not.toHaveBeenCalled();
+  });
+});

package/src/persistence/conversation-search-lexical.ts

@@ -0,0 +1,48 @@
+/**
+ * Shared lexical candidate helper for message-content search.
+ *
+ * Encodes a free-text query with the local TF-IDF sparse encoder and queries
+ * the BM25-style sparse Qdrant lexical index (`messages_lexical`) for matching
+ * message ids. This is the single entry point the message-search read sites use
+ * when the `messages-search-backend` flag selects `qdrant`, mirroring the
+ * candidate set SQLite FTS5 would return.
+ */
+
+import { generateSparseEmbedding } from "./embeddings/embedding-backend.js";
+import {
+  getMessagesLexicalIndex,
+  type MessageLexicalSearchResult,
+} from "./embeddings/messages-lexical-index.js";
+
+/**
+ * Resolve message-id candidates for `query` from the Qdrant lexical index,
+ * ranked by sparse similarity score (highest first).
+ *
+ * This is a **pure lexical candidate generator**: it returns the top-`limit`
+ * message ids by sparse score with NO visibility, source, or
+ * active-conversation filtering (the only scoping it applies is the optional
+ * `conversationId` restriction). Those exclusions (active conversation,
+ * private conversations, non-message sources) live in SQL at the read sites.
+ *
+ * Callers that apply such post-retrieval SQL filters MUST over-fetch: pass an
+ * inflated `limit` (the `CONVERSATION_SEARCH_PREFETCH_MULTIPLIER` prefetch
+ * pattern the recall source uses) and re-limit after filtering in SQL.
+ * Applying the caller's real limit here first would let excluded rows consume
+ * the candidate slots and drop valid visible matches below the fold.
+ *
+ * @param query          free-text search query
+ * @param limit          maximum number of candidates to return
+ * @param opts.conversationId  restrict results to a single conversation
+ */
+export async function searchMessageIdsLexical(
+  query: string,
+  limit: number,
+  opts?: { conversationId?: string },
+): Promise<MessageLexicalSearchResult[]> {
+  const sparse = generateSparseEmbedding(query);
+  // A query that tokenizes to nothing (whitespace/punctuation-only) yields an
+  // empty sparse vector; matching the FTS paths and other sparse callers,
+  // return no candidates without querying Qdrant on an empty vector.
+  if (sparse.indices.length === 0) return [];
+  return getMessagesLexicalIndex().searchLexical(sparse, limit, opts);
+}

package/src/persistence/jobs-worker.ts

@@ -1,5 +1,3 @@
-import { join } from "node:path";
-
 import { getConfig } from "../config/loader.js";
 import { isMemoryV3Live } from "../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../config/types.js";
@@ -8,9 +6,7 @@ import {
   diskPressureBackgroundSkipLogFields,
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
-import { countBufferLines } from "../plugins/defaults/memory/v2/consolidation-job.js";
 import { getLogger } from "../util/logger.js";
-import { getWorkspaceDir } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import {
   getLastScheduledCleanupEnqueueMs,
@@ -796,8 +792,10 @@ export function maybeEnqueueGraphMaintenanceJobs(
       // The checkpoint advances so the next check fires after the regular
       // interval. Manual "Run now" is unaffected (routes layer, not schedule).
       if (jobType === consolidateEntry.jobType) {
-        const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
-        if (countBufferLines(bufferPath) < MIN_BUFFER_LINES_FOR_CONSOLIDATION) {
+        if (
+          getMemoryPersistenceHooks().countMemoryBufferLines() <
+          MIN_BUFFER_LINES_FOR_CONSOLIDATION
+        ) {
           log.debug(
             "Scheduled consolidation skipped: buffer under minimum line threshold",
           );
@@ -830,8 +828,7 @@ export function maybeEnqueueGraphMaintenanceJobs(
     maxLines !== null &&
     !hasActiveJobOfType(consolidateEntry.jobType)
   ) {
-    const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
-    if (countBufferLines(bufferPath) >= maxLines) {
+    if (getMemoryPersistenceHooks().countMemoryBufferLines() >= maxLines) {
       enqueueMemoryJob(
         consolidateEntry.jobType,
         AUTOMATIC_CONSOLIDATION_JOB_PAYLOAD,

package/src/persistence/memory-lifecycle-hooks.test.ts

@@ -24,6 +24,9 @@ const baseHooks: MemoryPersistenceHooks = {
     return 0;
   },
   onWorkerStartup() {},
+  countMemoryBufferLines() {
+    return 0;
+  },
 };
 
 describe("memory persistence-lifecycle seam", () => {
@@ -34,6 +37,18 @@ describe("memory persistence-lifecycle seam", () => {
     await getMemoryPersistenceHooks().onMessagePersisted(event);
   });
 
+  test("countMemoryBufferLines defaults to 0 when memory is not present", () => {
+    expect(getMemoryPersistenceHooks().countMemoryBufferLines()).toBe(0);
+  });
+
+  test("countMemoryBufferLines returns the registered implementation's count", () => {
+    registerMemoryPersistenceHooks({
+      ...baseHooks,
+      countMemoryBufferLines: () => 42,
+    });
+    expect(getMemoryPersistenceHooks().countMemoryBufferLines()).toBe(42);
+  });
+
   test("getMemoryPersistenceHooks returns the registered implementation", async () => {
     const seen: MessagePersistedEvent[] = [];
     registerMemoryPersistenceHooks({

package/src/persistence/memory-lifecycle-hooks.ts

@@ -2,7 +2,8 @@ import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import type { DrizzleDb } from "./db-connection.js";
 
 /**
- * Seam for the memory feature to react to persistence-layer lifecycle events.
+ * Seam for the memory feature to react to persistence-layer lifecycle events
+ * and to answer memory-domain queries the persistence layer needs.
  *
  * Persistence is a layer below the memory plugin, so it cannot import memory
  * internals directly. Instead it calls into this registered-handler seam: the
@@ -89,6 +90,15 @@ export interface MemoryPersistenceHooks {
    * wraps it in try/catch. Cleanup — runs even while the plugin is disabled.
    */
   onWorkerStartup(): void;
+
+  /**
+   * Current line count of the memory buffer (`memory/buffer.md`). The
+   * maintenance scheduler reads it to gate scheduled consolidation — skip a
+   * scheduled run below a floor, force one above a ceiling. Returns 0 when
+   * memory is not present, which the scheduler reads as "no buffered work" and
+   * therefore no consolidation.
+   */
+  countMemoryBufferLines(): number;
 }
 
 const NOOP: MemoryPersistenceHooks = {
@@ -98,6 +108,9 @@ const NOOP: MemoryPersistenceHooks = {
     return 0;
   },
   onWorkerStartup() {},
+  countMemoryBufferLines() {
+    return 0;
+  },
 };
 
 let current: MemoryPersistenceHooks = NOOP;

package/src/plugins/defaults/index.ts

@@ -527,6 +527,14 @@ export function guardPersistenceHooksByDisabledState(
       if (isPluginDisabled(pluginName)) return;
       return hooks.onConversationForked(event);
     },
+    // Gated like the active side effects above: a disabled plugin reports an
+    // empty buffer, so the maintenance scheduler treats it as "no buffered
+    // work" and skips consolidation — matching how disabled injectors/hooks go
+    // inert.
+    countMemoryBufferLines() {
+      if (isPluginDisabled(pluginName)) return 0;
+      return hooks.countMemoryBufferLines();
+    },
     // Cleanup hooks are NOT gated on disabled-state: they must run even while
     // the plugin is disabled, or jobs/conversations created while it was
     // enabled would be orphaned.

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

@@ -57,6 +57,7 @@ afterAll(() => {
     process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceEnv;
   }
   rmSync(tmpWorkspace, { recursive: true, force: true });
+  resetMemoryPersistenceHooksForTests();
 });
 
 const { getMemoryDb } =
@@ -70,6 +71,14 @@ const { getMemoryCheckpoint, setMemoryCheckpoint, deleteMemoryCheckpoint } =
   await import("../../../../persistence/checkpoints.js");
 const { maybeEnqueueGraphMaintenanceJobs } =
   await import("../../../../persistence/jobs-worker.js");
+const { registerMemoryPersistenceHooks, resetMemoryPersistenceHooksForTests } =
+  await import("../../../../persistence/memory-lifecycle-hooks.js");
+const { memoryPersistenceHooks } = await import("../persistence-hooks.js");
+
+// The scheduler reads the memory buffer's line count through the persistence
+// seam; register the real memory implementation so `countMemoryBufferLines`
+// reflects the buffer files these tests write.
+registerMemoryPersistenceHooks(memoryPersistenceHooks);
 
 const CONSOLIDATE_CHECKPOINT_KEY = "memory_v2_consolidate_last_run";
 

package/src/plugins/defaults/memory/persistence-hooks.ts

@@ -1,9 +1,12 @@
+import { join } from "node:path";
+
 import { getConfig } from "../../../config/loader.js";
 import type {
   ConversationForkedEvent,
   MemoryPersistenceHooks,
   MessagePersistedEvent,
 } from "../../../persistence/memory-lifecycle-hooks.js";
+import { getWorkspaceDir } from "../../../util/platform.js";
 import { forkGraphMemoryState } from "./graph/graph-memory-state-store.js";
 import { indexMessageNow } from "./indexer.js";
 import { sweepOrphanMemoryRetrospectiveConversations } from "./memory-retrospective-startup-cleanup.js";
@@ -13,6 +16,7 @@ import {
   forkActivationState,
   seedForkActivationState,
 } from "./v2/activation-store.js";
+import { countBufferLines } from "./v2/consolidation-job.js";
 import {
   extractInjectedConceptSlugs,
   readInjectedBlock,
@@ -116,4 +120,8 @@ export const memoryPersistenceHooks: MemoryPersistenceHooks = {
   onWorkerStartup(): void {
     sweepOrphanMemoryRetrospectiveConversations();
   },
+
+  countMemoryBufferLines(): number {
+    return countBufferLines(join(getWorkspaceDir(), "memory", "buffer.md"));
+  },
 };

package/src/skills/validate-input.ts

@@ -102,6 +102,53 @@ export function coerceStringBooleans(
   return coerced ?? input;
 }
 
+/**
+ * Coerce finite JSON numbers to strings for properties the schema declares as
+ * `type: "string"`.
+ *
+ * Some providers' models emit numeric-looking string values as unquoted JSON
+ * numbers (e.g. a phone number `15550100` instead of `"+15550100"`).
+ * Plain `JSON.parse` yields a JS `Number`, which then fails the validator's
+ * `typeof === "string"` check with a confusing "must be a string" error that
+ * sends the model down a wrong retry path. The value's intent is unambiguous —
+ * a string field received a number — so coerce it the same way we coerce
+ * string-encoded booleans. The E.164 / format / enum checks downstream still
+ * run on the coerced string, so a number missing a `+` prefix still gets a
+ * self-correcting format error rather than a type error.
+ *
+ * Only finite numbers are coerced; `NaN`/`Infinity` (which can't come from
+ * JSON.parse anyway) and non-number types are left untouched. Integers outside
+ * the safe range are also left untouched: `JSON.parse` has already rounded them
+ * (e.g. `12345678901234567890` → `12345678901234567000`), so `String()` would
+ * emit a corrupted identifier. Leaving them un-coerced makes the validator
+ * return a type error, prompting the model to retry with a quoted string that
+ * preserves every digit. Pure: returns a new object when a coercion applies,
+ * otherwise returns `input` unchanged. Never mutates `input` or `schema`.
+ */
+export function coerceStringNumbers(
+  input: Record<string, unknown>,
+  schema: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+  if (!schema) return input;
+  const properties = schema.properties;
+  if (!isPlainObject(properties)) return input;
+
+  let coerced: Record<string, unknown> | undefined;
+  for (const [key, rawSubSchema] of Object.entries(properties)) {
+    if (!isPlainObject(rawSubSchema)) continue;
+    if (rawSubSchema.type !== "string") continue;
+    const value = input[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) continue;
+    // An integer beyond the safe range was already rounded by JSON.parse;
+    // coercing it would lock in a corrupted identifier. Skip it so validation
+    // fails and the model retries with a lossless quoted string.
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) continue;
+    coerced ??= { ...input };
+    coerced[key] = String(value);
+  }
+  return coerced ?? input;
+}
+
 /**
  * Validate a tool input object against the (optional) JSON-schema definition
  * declared on the tool entry. Returns `{ ok: true }` if the input is valid (or

package/src/tools/skills/skill-tool-factory.ts

@@ -2,6 +2,7 @@ import type { SkillToolEntry } from "../../config/skills.js";
 import { RiskLevel } from "../../permissions/types.js";
 import {
   coerceStringBooleans,
+  coerceStringNumbers,
   validateInputAgainstSchema,
 } from "../../skills/validate-input.js";
 import type {
@@ -46,7 +47,10 @@ export function createSkillTool(
       context: ToolContext,
     ): Promise<ToolExecutionResult> {
       const schema = entry.input_schema as Record<string, unknown> | undefined;
-      const coercedInput = coerceStringBooleans(input, schema);
+      const coercedInput = coerceStringNumbers(
+        coerceStringBooleans(input, schema),
+        schema,
+      );
       const validation = validateInputAgainstSchema(
         entry.name,
         coercedInput,

package/src/util/__tests__/process-tree.test.ts

@@ -39,8 +39,16 @@ describe("deriveName", () => {
     expect(deriveName("bun run /worker.ts")).toBe("worker");
   });
 
-  test("falls back to the interpreter when there is no script arg", () => {
-    expect(deriveName("bun repl")).toBe("bun");
+  test("surfaces the arguments when an interpreter runs no script file", () => {
+    expect(deriveName("bun repl")).toBe("bun repl");
+    expect(deriveName("bun run dev")).toBe("bun run dev");
+    expect(deriveName("bun x prettier --write .")).toBe("bun x prettier .");
+    expect(deriveName("node --inspect server")).toBe("node server");
+  });
+
+  test("falls back to the bare interpreter when only flags follow", () => {
+    expect(deriveName("bun --version")).toBe("bun");
+    expect(deriveName("bun")).toBe("bun");
   });
 
   test("handles empty input", () => {

package/src/util/process-tree.ts

@@ -64,7 +64,10 @@ function scriptName(scriptPath: string): string {
  * Derive a readable name from a command line. For interpreter invocations
  * (`bun run /…/jobs/worker.ts`) the script path is far more useful than the
  * interpreter name, so prefer the first script-looking argument and summarize it
- * as `<parent-dir>-<filename>` (e.g. `jobs-worker`). Plain binaries
+ * as `<parent-dir>-<filename>` (e.g. `jobs-worker`). When an interpreter is run
+ * without a script file (`bun run dev`, `bun x prettier`, `bun repl`) the bare
+ * interpreter name says nothing about what is running, so surface the arguments
+ * — what was actually run — alongside it (e.g. `bun run dev`). Plain binaries
  * (`/…/vellum-qdrant`) keep their bare executable name.
  */
 export function deriveName(command: string): string {
@@ -73,8 +76,13 @@ export function deriveName(command: string): string {
 
   const argv0 = basename(tokens[0]);
   if (RUNTIMES.has(argv0)) {
-    const script = tokens.slice(1).find((t) => SCRIPT_EXT_RE.test(t));
+    const args = tokens.slice(1);
+    const script = args.find((t) => SCRIPT_EXT_RE.test(t));
     if (script) return scriptName(script);
+    // No script to summarize: show the non-flag arguments so the entry reads as
+    // "what was run" rather than an opaque `bun`. Flags are dropped as noise.
+    const meaningful = args.filter((t) => !t.startsWith("-"));
+    if (meaningful.length > 0) return `${argv0} ${meaningful.join(" ")}`;
   }
   return argv0;
 }