@vellumai/assistant 0.8.4 → 0.8.5

package/src/daemon/message-types/sync.ts

@@ -7,6 +7,8 @@ export const SYNC_TAGS = {
   assistantSounds: "assistant:self:sounds",
   assistantSchedules: "assistant:self:schedules",
   conversationsList: "conversations:list",
+  featureFlagsClient: "feature-flags:client",
+  featureFlagsAssistant: "feature-flags:assistant",
 } as const;
 
 export type KnownSyncInvalidationTag =
@@ -24,6 +26,14 @@ export type SyncInvalidationTag =
 export interface SyncChangedMessage {
   type: "sync_changed";
   tags: SyncInvalidationTag[];
+  /**
+   * Optional identifier of the client that originated the change. When set,
+   * the server fan-out and clients themselves can suppress self-echoes so
+   * the originating tab/process doesn't reinvalidate its own cache off its
+   * own mutation. Daemon-internal emits (agent loop, FS watcher, cron) leave
+   * this unset so the event fans out to every subscriber as before.
+   */
+  originClientId?: string;
 }
 
 export const SyncInvalidationTagSchema = z.string().min(1);
@@ -32,6 +42,7 @@ export const SyncChangedMessageSchema = z
   .object({
     type: z.literal("sync_changed"),
     tags: z.array(SyncInvalidationTagSchema).min(1),
+    originClientId: z.string().min(1).optional(),
   })
   .strict();
 
@@ -49,11 +60,14 @@ export function conversationMetadataSyncTag(
 
 export function buildSyncChangedMessage(
   tags: SyncInvalidationTag[],
+  originClientId?: string,
 ): SyncChangedMessage {
   const dedupedTags = Array.from(new Set(tags));
+  const trimmedOrigin = originClientId?.trim();
   const parsed = SyncChangedMessageSchema.parse({
     type: "sync_changed",
     tags: dedupedTags,
+    ...(trimmedOrigin ? { originClientId: trimmedOrigin } : {}),
   });
   return parsed as SyncChangedMessage;
 }

package/src/daemon/shutdown-handlers.ts

@@ -34,10 +34,9 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
   let shuttingDown = false;
   let exitCode = 0;
 
-  const shutdown = async () => {
+  const shutdown = async (_signal?: NodeJS.Signals) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    log.info("Shutting down daemon...");
 
     // Force exit if graceful shutdown takes too long.
     // Set this BEFORE awaiting heartbeat stop so it covers all
@@ -156,9 +155,29 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     process.exit(exitCode);
   };
 
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-  process.on("SIGHUP", shutdown);
+  process.on("SIGTERM", () => {
+    log.warn(
+      { signal: "SIGTERM", pid: process.pid, uptime: process.uptime() },
+      "Received SIGTERM — process termination requested",
+    );
+    void shutdown("SIGTERM");
+  });
+
+  process.on("SIGINT", () => {
+    log.warn(
+      { signal: "SIGINT", pid: process.pid, uptime: process.uptime() },
+      "Received SIGINT — user interrupt",
+    );
+    void shutdown("SIGINT");
+  });
+
+  process.on("SIGHUP", () => {
+    log.warn(
+      { signal: "SIGHUP", pid: process.pid, uptime: process.uptime() },
+      "Received SIGHUP — terminal hangup",
+    );
+    void shutdown("SIGHUP");
+  });
 
   process.on("unhandledRejection", (reason) => {
     log.error(

package/src/daemon/switch-inference-profile-tool.ts

@@ -0,0 +1,52 @@
+import type { ProfileEntry } from "../config/schemas/llm.js";
+import type { ToolDefinition } from "../providers/types.js";
+
+export const SWITCH_INFERENCE_PROFILE_TOOL_NAME = "switch_inference_profile";
+
+const PROFILE_DESCRIPTION_FALLBACKS: Record<string, string> = {
+  "quality-optimized":
+    "Most capable model for complex reasoning, multi-step analysis, math, and coding",
+  balanced: "Good balance of quality, cost, and speed for most tasks",
+  "cost-optimized":
+    "Fast responses for simple factual questions, short lookups, and casual chat",
+};
+
+export function buildSwitchInferenceProfileToolDef(
+  profiles: Record<string, ProfileEntry>,
+  currentProfile?: string,
+): ToolDefinition | null {
+  const entries = Object.entries(profiles).filter(
+    ([, entry]) => entry.status !== "disabled",
+  );
+  if (entries.length < 2) return null;
+
+  const profileDescriptions = entries
+    .map(([key, entry]) => {
+      const label = entry.label ?? key;
+      const desc =
+        entry.description || PROFILE_DESCRIPTION_FALLBACKS[key] || "";
+      const descSuffix = desc ? `: ${desc}` : "";
+      const current = key === currentProfile ? " (current)" : "";
+      return `- ${key} — ${label}${descSuffix}${current}`;
+    })
+    .join("\n");
+
+  const currentEntry = currentProfile ? profiles[currentProfile] : undefined;
+  const currentLabel = currentEntry?.label ?? currentProfile ?? "current";
+
+  return {
+    name: SWITCH_INFERENCE_PROFILE_TOOL_NAME,
+    description: `Switch to a different inference profile BEFORE answering. You MUST call this tool when the user's query requires capabilities beyond what your current profile ("${currentLabel}") provides. Examples of when to switch to a more capable profile: multi-step reasoning or analysis, math proofs or derivations, complex coding tasks, detailed creative writing, or any task requiring deep thought. Examples of when to switch to a faster profile: simple greetings, one-word answers, factual lookups. When in doubt about whether you can handle the query well, switch to a more capable profile.\n\nAvailable profiles:\n${profileDescriptions}`,
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        profile: {
+          type: "string",
+          enum: entries.map(([key]) => key),
+          description: "The profile key to switch to.",
+        },
+      },
+      required: ["profile"],
+    },
+  };
+}

package/src/daemon/tool-setup-types.ts

@@ -57,4 +57,17 @@ export interface ToolSetupContext extends SurfaceConversationContext {
    * return `undefined` for the in-flight (background) subagent.
    */
   currentTurnOverrideProfile?: string;
+  /**
+   * Set by the `switch_inference_profile` tool when the model self-selects a
+   * different profile mid-turn. Read by `readCurrentOverrideProfile` in the
+   * agent loop so the next LLM call uses the switched profile. Reset at
+   * turn start.
+   */
+  toolRoutedProfile?: string;
+  /**
+   * True when the user has explicitly selected an inference profile for this
+   * conversation (via the composer profile picker). When set, tool-based
+   * auto-routing is suppressed — the user's explicit choice takes precedence.
+   */
+  hasExplicitProfileOverride?: boolean;
 }

package/src/events/relationship-state-updated.ts

@@ -0,0 +1,25 @@
+/**
+ * `relationship_state_updated` SSE event.
+ *
+ * Broadcast by the daemon after a successful write of
+ * `relationship-state.json` to disk. Subscribers refetch
+ * `GET /v1/home/state` to read the new state — payload here just
+ * carries the new `updatedAt` for cache-tag comparison.
+ *
+ * Canonical wire-contract source. Daemon code imports the type
+ * directly from this file; external consumers import via
+ * `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const RelationshipStateUpdatedSchema = z
+  .object({
+    type: z.literal("relationship_state_updated"),
+    updatedAt: z.string(),
+  })
+  .strict();
+
+export type RelationshipStateUpdated = z.infer<
+  typeof RelationshipStateUpdatedSchema
+>;

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -14,6 +14,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
     publish: publishSpy,
     subscribe: () => () => {},
   },
+  broadcastMessage: () => {},
 }));
 
 // Stub workspace prompt reads so the heartbeat service doesn't try to
@@ -99,7 +100,6 @@ mock.module("../../prompts/persona-resolver.js", () => ({
 }));
 mock.module("../../prompts/system-prompt.js", () => ({
   isTemplateContent: () => false,
-  SYSTEM_PROMPT_CACHE_BOUNDARY: "<<CACHE_BOUNDARY>>",
   buildCoreIdentityContext: () => "",
   buildSystemPrompt: () => "",
   ensurePromptFiles: () => {},

package/src/home/home-greeting.ts

@@ -13,7 +13,6 @@
 
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
-import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { getConfiguredProvider } from "../providers/provider-send-message.js";
 import { runBtwSidechain } from "../runtime/btw-sidechain.js";
@@ -56,17 +55,9 @@ export async function refreshPersonalizedGreeting(): Promise<void> {
       return;
     }
 
-    const { userPersona, userSlug, channelPersona } = resolvePersonaContext(
-      undefined,
-      undefined,
-    );
-
     const systemPrompt = buildSystemPrompt({
       excludeBootstrap: true,
       excludeCustomPrefix: true,
-      userPersona,
-      channelPersona,
-      userSlug,
     });
 
     const result = await runBtwSidechain({

package/src/home/suggested-prompts.ts

@@ -16,7 +16,6 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { listProviders } from "../oauth/oauth-store.js";
-import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { getConfiguredProvider } from "../providers/provider-send-message.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
@@ -234,17 +233,9 @@ async function generateAssistantPrompts(
     return [];
   }
 
-  const { userPersona, userSlug, channelPersona } = resolvePersonaContext(
-    undefined,
-    undefined,
-  );
-
   const systemPrompt = buildSystemPrompt({
     excludeBootstrap: true,
     excludeCustomPrefix: true,
-    userPersona,
-    channelPersona,
-    userSlug,
   });
 
   const existingLabels = deterministicPrompts.map((p) => p.label).join(", ");

package/src/ipc/gateway-flag-listener.ts

@@ -0,0 +1,123 @@
+import { connect, type Socket } from "node:net";
+
+import { refreshOverridesFromGateway } from "../config/assistant-feature-flags.js";
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
+import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
+import { getLogger } from "../util/logger.js";
+import { resolveIpcSocketPath } from "./socket-path.js";
+
+const log = getLogger("gateway-flag-listener");
+
+const MAX_BACKOFF_MS = 30_000;
+const INITIAL_BACKOFF_MS = 1_000;
+
+let socket: Socket | null = null;
+let stopped = false;
+let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+let currentBackoffMs = INITIAL_BACKOFF_MS;
+
+function getSocketPath(): string {
+  return resolveIpcSocketPath("gateway").path;
+}
+
+function handleData(chunk: Buffer): void {
+  const lines = chunk.toString().split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const msg = JSON.parse(trimmed) as { event?: string };
+      if (msg.event === "feature_flags_changed") {
+        log.info("Received feature_flags_changed event — refreshing overrides");
+        refreshOverridesFromGateway().catch((err) => {
+          log.warn({ err }, "Failed to refresh feature flag overrides");
+        });
+        // Fan out to every connected web client so React Query caches
+        // for `/v1/feature-flags/client-flag-values/` and
+        // `/v1/assistants/:id/feature-flags` invalidate immediately
+        // instead of waiting on a 5s polling tick.
+        publishSyncInvalidation([
+          SYNC_TAGS.featureFlagsClient,
+          SYNC_TAGS.featureFlagsAssistant,
+        ]).catch((err) => {
+          log.warn({ err }, "Failed to broadcast feature-flags sync_changed");
+        });
+      }
+    } catch {
+      // Ignore non-JSON lines (e.g. IPC responses on a shared socket)
+    }
+  }
+}
+
+function scheduleReconnect(): void {
+  if (stopped) return;
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    connectToGateway();
+  }, currentBackoffMs);
+  currentBackoffMs = Math.min(currentBackoffMs * 2, MAX_BACKOFF_MS);
+}
+
+function connectToGateway(): void {
+  if (stopped) return;
+
+  const socketPath = getSocketPath();
+  const conn = connect(socketPath);
+
+  conn.on("connect", () => {
+    if (stopped) {
+      conn.destroy();
+      return;
+    }
+    log.info("Connected to gateway IPC for flag events");
+    currentBackoffMs = INITIAL_BACKOFF_MS;
+    socket = conn;
+    refreshOverridesFromGateway().catch((err) => {
+      log.warn({ err }, "Failed to refresh feature flag overrides on reconnect");
+    });
+  });
+
+  let buffer = "";
+  conn.on("data", (chunk) => {
+    buffer += chunk.toString();
+    let newlineIdx: number;
+    while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, newlineIdx);
+      buffer = buffer.slice(newlineIdx + 1);
+      if (line.trim()) {
+        handleData(Buffer.from(line));
+      }
+    }
+  });
+
+  conn.on("close", () => {
+    socket = null;
+    if (!stopped) {
+      log.debug("Gateway IPC connection closed — reconnecting");
+      scheduleReconnect();
+    }
+  });
+
+  conn.on("error", (err) => {
+    log.debug({ err }, "Gateway IPC connection error");
+    conn.destroy();
+  });
+}
+
+export function startGatewayFlagListener(): void {
+  stopped = false;
+  currentBackoffMs = INITIAL_BACKOFF_MS;
+  connectToGateway();
+}
+
+export function stopGatewayFlagListener(): void {
+  stopped = true;
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+  if (socket) {
+    socket.destroy();
+    socket = null;
+  }
+}

package/src/ipc/skill-routes/registries.ts

@@ -22,12 +22,9 @@ import { z } from "zod";
 import type { MeetHostSupervisor } from "../../daemon/meet-host-supervisor.js";
 import { registerShutdownHook } from "../../daemon/shutdown-registry.js";
 import { registerSkillRoute } from "../../runtime/skill-route-registry.js";
+import { resolveExecutionTarget } from "../../tools/execution-target.js";
 import { registerSkillTools } from "../../tools/registry.js";
-import type {
-  ExecutionTarget,
-  Tool,
-  ToolDefinition,
-} from "../../tools/types.js";
+import type { ExecutionTarget, Tool } from "../../tools/types.js";
 import { RiskLevel } from "../../tools/types.js";
 import { getLogger } from "../../util/logger.js";
 import type { SkillIpcRoute } from "../skill-ipc-types.js";
@@ -182,25 +179,24 @@ export function __getActiveSessionCountForTesting(): number {
  * exercised end-to-end.
  */
 function buildProxyTool(manifest: ToolManifest): Tool {
-  const definition: ToolDefinition = {
-    name: manifest.name,
-    description: manifest.description,
-    input_schema: manifest.input_schema as object,
-  };
   // RiskLevel is a string enum whose values are "low" | "medium" | "high",
   // matching the schema above exactly — the cast is a no-op at runtime.
   return {
     name: manifest.name,
     description: manifest.description,
+    input_schema: manifest.input_schema as object,
     category: manifest.category,
     defaultRiskLevel: manifest.defaultRiskLevel as RiskLevel,
     executionMode: manifest.executionMode ?? "proxy",
-    executionTarget: manifest.executionTarget as ExecutionTarget | undefined,
+    executionTarget: resolveExecutionTarget({
+      name: manifest.name,
+      executionTarget: manifest.executionTarget as ExecutionTarget | undefined,
+      executionMode: manifest.executionMode ?? "proxy",
+    }),
     origin: "skill",
     ownerSkillId: manifest.ownerSkillId,
     ownerSkillBundled: manifest.ownerSkillBundled,
     ownerSkillVersionHash: manifest.ownerSkillVersionHash,
-    getDefinition: () => definition,
     execute: async () => {
       // Only reached when no supervisor is attached (tests/boot race);
       // the supervisor short-circuit above replaces this with the

package/src/memory/__tests__/db-async-query.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Tests for `db-async-query.ts` — the runAsyncSqlite abstraction.
+ *
+ * The contract this PR locks in:
+ *   1. **The main event loop keeps ticking while a long SQLite
+ *      statement is in flight via the sqlite3 CLI backend.** This is
+ *      the structural anti-block assertion — a recursive `setImmediate`
+ *      probe counts event-loop iterations during the operation; if
+ *      anyone moves the slow path back onto the main thread,
+ *      `bun:sqlite` is synchronous and tick counting collapses to ~0;
+ *      this test fails loudly.
+ *   2. The CLI backend reports `backend: "sqlite3-cli"` and `ok: true`
+ *      on success.
+ *   3. The in-process fallback backend executes the statement
+ *      synchronously and reports `backend: "in-process-blocking"`.
+ *   4. Errors from sqlite3 surface as `ok: false` with the stderr
+ *      preserved in `error`.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+const { getSqlite } = await import("../db-connection.js");
+const { initializeDb } = await import("../db-init.js");
+const { runAsyncSqlite, _resetFallbackWarning } =
+  await import("../db-async-query.js");
+const { findSqlite3 } = await import("../../util/sqlite3-runtime.js");
+
+initializeDb();
+
+const sqlite3Available = findSqlite3() !== undefined;
+
+beforeEach(() => {
+  _resetFallbackWarning();
+});
+
+function inflateAndDelete(byteTarget: number): void {
+  const sqlite = getSqlite();
+  sqlite.exec(
+    "CREATE TABLE IF NOT EXISTS async_bloat (id INTEGER PRIMARY KEY, payload BLOB)",
+  );
+  const pageSize = (
+    sqlite.query("PRAGMA page_size").get() as { page_size: number }
+  ).page_size;
+  const rowsTarget = Math.max(1, Math.ceil(byteTarget / pageSize));
+  const payload = new Uint8Array(Math.max(1, pageSize - 64));
+  const insert = sqlite.prepare("INSERT INTO async_bloat (payload) VALUES (?)");
+  sqlite.exec("BEGIN");
+  for (let i = 0; i < rowsTarget; i++) {
+    insert.run(payload);
+  }
+  sqlite.exec("COMMIT");
+  sqlite.exec("DELETE FROM async_bloat");
+  sqlite.exec("DROP TABLE async_bloat");
+  sqlite.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+}
+
+describe("runAsyncSqlite", () => {
+  test("returns ok=true for a trivial statement", async () => {
+    const result = await runAsyncSqlite("SELECT 1");
+    expect(result.ok).toBe(true);
+    expect(result.error).toBeNull();
+  });
+
+  test("in-process fallback reports the right backend", async () => {
+    const result = await runAsyncSqlite("SELECT 1", {
+      forceBackend: "in-process-blocking",
+    });
+    expect(result.ok).toBe(true);
+    expect(result.backend).toBe("in-process-blocking");
+  });
+
+  test("in-process fallback emits changes() count on stdout after a DELETE", async () => {
+    // Regression for Codex P1 on #31894: callers (e.g. prune jobs) rely
+    // on reading the row count off `result.stdout`. The CLI backend
+    // populates this naturally when the SQL ends with `SELECT changes();`,
+    // but `bun:sqlite`'s `exec()` discards SELECT results — so the
+    // in-process backend has to synthesize the same line, or the
+    // re-enqueue gate in pruneOld*Job silently never fires on hosts
+    // without the sqlite3 CLI.
+    const sqlite = getSqlite();
+    sqlite.exec(
+      "CREATE TABLE IF NOT EXISTS async_changes_probe (id INTEGER PRIMARY KEY)",
+    );
+    sqlite.exec("DELETE FROM async_changes_probe");
+    sqlite.exec(
+      "INSERT INTO async_changes_probe (id) VALUES (1),(2),(3),(4),(5)",
+    );
+
+    const result = await runAsyncSqlite(
+      "DELETE FROM async_changes_probe WHERE id <= 3; SELECT changes();",
+      { forceBackend: "in-process-blocking" },
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.backend).toBe("in-process-blocking");
+    // The synthesized stdout matches what the CLI backend would emit:
+    // a bare integer on its own line. The exact format keeps the
+    // parser in cleanup.ts backend-agnostic.
+    expect(result.stdout).toBe("3\n");
+
+    sqlite.exec("DROP TABLE async_changes_probe");
+  });
+
+  test.if(sqlite3Available)(
+    "sqlite3 CLI backend reports the right backend on success",
+    async () => {
+      const result = await runAsyncSqlite("SELECT 1");
+      expect(result.ok).toBe(true);
+      expect(result.backend).toBe("sqlite3-cli");
+    },
+  );
+
+  test.if(sqlite3Available)(
+    "surfaces sqlite3 errors as ok=false with the message preserved",
+    async () => {
+      // Intentional SQL syntax error.
+      const result = await runAsyncSqlite("THIS IS NOT VALID SQL");
+      expect(result.ok).toBe(false);
+      expect(result.backend).toBe("sqlite3-cli");
+      expect(result.error).toBeTruthy();
+    },
+  );
+
+  test.if(sqlite3Available)(
+    "VACUUM via sqlite3 CLI keeps the event loop ticking (anti-block)",
+    async () => {
+      // Inflate the DB so VACUUM has measurable work to do. Without
+      // this the subprocess finishes in single-digit ms and the
+      // probe has no opportunity to record meaningful ticks.
+      inflateAndDelete(8 * 1024 * 1024);
+
+      // Probe the event loop with recursive setImmediate. This fires
+      // on every event-loop iteration with no minimum delay, so on a
+      // healthy unblocked loop it produces tens of thousands of ticks
+      // per second (vs. setInterval(1) which is capped by the host's
+      // timer resolution — observed at ~32 ms on GitHub Actions
+      // runners). If anyone moves VACUUM back onto the main thread,
+      // `bun:sqlite` is sync and tick count collapses to ~0; the
+      // assertion below fails loudly. The signal is intentionally
+      // binary: "many" vs "none".
+      let tickCount = 0;
+      let probing = true;
+      const tick = (): void => {
+        if (!probing) return;
+        tickCount += 1;
+        setImmediate(tick);
+      };
+      setImmediate(tick);
+
+      let result;
+      try {
+        result = await runAsyncSqlite("VACUUM");
+      } finally {
+        probing = false;
+      }
+
+      expect(result.ok).toBe(true);
+      expect(result.backend).toBe("sqlite3-cli");
+
+      // Any positive tick count proves the event loop wasn't blocked.
+      // A sync in-process VACUUM would collapse this to 0.
+      expect(tickCount).toBeGreaterThanOrEqual(1);
+    },
+    60_000,
+  );
+});