@vellumai/assistant 0.8.6 → 0.8.7

package/src/daemon/process-message.ts

@@ -65,16 +65,14 @@ const log = getLogger("process-message");
 type ProcessMessageOptions = ConversationCreateOptions & {
   /** Per-turn observer for live agent-loop events. Does not replace SSE broadcast. */
   onEvent?: (msg: ServerMessage) => void;
+  /** IDs of user-uploaded attachments to resolve and include in the turn. */
+  attachmentIds?: string[];
+  /** Originating channel (e.g. "slack", "telegram"). Defaults to "vellum". */
+  sourceChannel?: string;
+  /** Originating interface (e.g. "cli", "web"). Defaults to "web". */
+  sourceInterface?: string;
 };
 
-function stripPerTurnObservers(
-  options?: ProcessMessageOptions,
-): ConversationCreateOptions | undefined {
-  if (!options) return undefined;
-  const { onEvent: _onEvent, ...conversationOptions } = options;
-  return conversationOptions;
-}
-
 function buildEventEmitter(
   observer?: (msg: ServerMessage) => void,
 ): (msg: ServerMessage) => void {
@@ -132,10 +130,7 @@ export function resolveTurnInterface(sourceInterface?: string): InterfaceId {
 async function prepareConversationForMessage(
   conversationId: string,
   content: string,
-  attachmentIds: string[] | undefined,
-  options: ConversationCreateOptions | undefined,
-  sourceChannel: string | undefined,
-  sourceInterface: string | undefined,
+  options?: ProcessMessageOptions,
 ): Promise<{
   conversation: Conversation;
   attachments: {
@@ -146,9 +141,18 @@ async function prepareConversationForMessage(
     filePath?: string;
   }[];
 }> {
+  const {
+    attachmentIds,
+    sourceChannel,
+    sourceInterface,
+    onEvent: _onEvent,
+    ...conversationOptions
+  } = options ?? {};
   const conversation = await getOrCreateActiveConversation(
     conversationId,
-    options,
+    Object.keys(conversationOptions).length > 0
+      ? conversationOptions
+      : undefined,
   );
 
   if (conversation.isProcessing()) {
@@ -157,7 +161,7 @@ async function prepareConversationForMessage(
 
   const resolvedChannel = resolveTurnChannel(
     sourceChannel,
-    options?.transport?.channelId,
+    conversationOptions.transport?.channelId,
   );
   const resolvedInterface = resolveTurnInterface(sourceInterface);
   conversation.setAssistantId(
@@ -191,8 +195,15 @@ async function prepareConversationForMessage(
         "wiring in conversation-routes.ts into a shared helper.",
     );
   }
+  const sourceActorPrincipalId = conversation.trustContext?.guardianPrincipalId;
   // CU is per-conversation (owns step count, AX tree history, loop detection).
-  if (shouldAttachHostProxyForCapability("host_cu", resolvedInterface)) {
+  if (
+    shouldAttachHostProxyForCapability(
+      "host_cu",
+      resolvedInterface,
+      sourceActorPrincipalId,
+    )
+  ) {
     if (!conversation.isProcessing() || !conversation.hostCuProxy) {
       conversation.setHostCuProxy(new HostCuProxy());
     }
@@ -204,7 +215,11 @@ async function prepareConversationForMessage(
   // is enforced by the skill-projection layer via SKILL.md frontmatter, so
   // an attached proxy is harmless when the flag is off.
   if (
-    shouldAttachHostProxyForCapability("host_app_control", resolvedInterface)
+    shouldAttachHostProxyForCapability(
+      "host_app_control",
+      resolvedInterface,
+      sourceActorPrincipalId,
+    )
   ) {
     if (!conversation.isProcessing() || !conversation.hostAppControlProxy) {
       conversation.setHostAppControlProxy(
@@ -216,7 +231,11 @@ async function prepareConversationForMessage(
   }
   // The early `isProcessing()` throw above guarantees the conversation is
   // idle here, so preactivation is unconditional once the proxies are wired.
-  preactivateHostProxySkills(conversation, resolvedInterface);
+  preactivateHostProxySkills(
+    conversation,
+    resolvedInterface,
+    sourceActorPrincipalId,
+  );
   conversation.setCommandIntent(options?.commandIntent ?? null);
   conversation.setTurnChannelContext({
     userMessageChannel: resolvedChannel,
@@ -253,19 +272,12 @@ async function prepareConversationForMessage(
 export async function processMessage(
   conversationId: string,
   content: string,
-  attachmentIds?: string[],
   options?: ProcessMessageOptions,
-  sourceChannel?: string,
-  sourceInterface?: string,
 ): Promise<{ messageId: string; assistantMessageId?: string }> {
-  const conversationOptions = stripPerTurnObservers(options);
   const { conversation, attachments } = await prepareConversationForMessage(
     conversationId,
     content,
-    attachmentIds,
-    conversationOptions,
-    sourceChannel,
-    sourceInterface,
+    options,
   );
   const emitEvent = buildEventEmitter(options?.onEvent);
 
@@ -327,7 +339,7 @@ export async function processMessage(
         attachments,
         options?.displayContent,
       ),
-      userMetaWithSlack,
+      { metadata: userMetaWithSlack },
     );
     conversation.getMessages().push(llmMsg);
 
@@ -377,7 +389,7 @@ export async function processMessage(
       conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
-      serverChannelMeta,
+      { metadata: serverChannelMeta },
     );
     conversation.getMessages().push(assistantMsg);
     publishConversationMessagesChanged(conversationId);
@@ -420,15 +432,11 @@ export async function processMessage(
         attachments,
         options?.displayContent,
       ),
-      compactUserMeta,
+      { metadata: compactUserMeta },
     );
     conversation.getMessages().push(cleanMsg);
 
-    conversation.emitActivityState(
-      "thinking",
-      "context_compacting",
-      "assistant_turn",
-    );
+    conversation.emitActivityState("thinking", "context_compacting");
     const result = await conversation.forceCompact({
       targetInputTokensOverride: slashResult.targetInputTokensOverride,
     });
@@ -438,7 +446,7 @@ export async function processMessage(
       conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
-      compactChannelMeta,
+      { metadata: compactChannelMeta },
     );
     conversation.getMessages().push(assistantMsg);
     publishConversationMessagesChanged(conversationId);
@@ -481,7 +489,7 @@ export async function processMessage(
         attachments,
         options?.displayContent,
       ),
-      cleanUserMeta,
+      { metadata: cleanUserMeta },
     );
     conversation.getMessages().push(cleanMsg);
 
@@ -492,7 +500,7 @@ export async function processMessage(
       conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
-      cleanChannelMeta,
+      { metadata: cleanChannelMeta },
     );
     conversation.getMessages().push(assistantMsg);
     publishConversationMessagesChanged(conversationId);
@@ -523,7 +531,8 @@ export async function processMessage(
   }
 
   try {
-    await conversation.runAgentLoop(resolvedContent, messageId, emitEvent, {
+    await conversation.runAgentLoop(resolvedContent, messageId, {
+      onEvent: emitEvent,
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
       ...(options?.callSite ? { callSite: options.callSite } : {}),
@@ -551,19 +560,12 @@ export async function processMessage(
 export async function processMessageInBackground(
   conversationId: string,
   content: string,
-  attachmentIds?: string[],
   options?: ProcessMessageOptions,
-  sourceChannel?: string,
-  sourceInterface?: string,
 ): Promise<{ messageId: string }> {
-  const conversationOptions = stripPerTurnObservers(options);
   const { conversation, attachments } = await prepareConversationForMessage(
     conversationId,
     content,
-    attachmentIds,
-    conversationOptions,
-    sourceChannel,
-    sourceInterface,
+    options,
   );
   const emitEvent = buildEventEmitter(options?.onEvent);
 
@@ -586,7 +588,8 @@ export async function processMessageInBackground(
   }
 
   conversation
-    .runAgentLoop(content, messageId, emitEvent, {
+    .runAgentLoop(content, messageId, {
+      onEvent: emitEvent,
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
       ...(options?.callSite ? { callSite: options.callSite } : {}),

package/src/daemon/server.ts

@@ -15,9 +15,11 @@ import { initializeProviders } from "../providers/registry.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getSigningKeyFingerprint } from "../runtime/auth/token-service.js";
 import {
+  publishAppsChanged,
   publishAvatarChanged,
   publishConfigChanged,
   publishIdentityChanged,
+  publishIdentityIntroChanged,
   publishSoundsConfigUpdated,
 } from "../runtime/sync/resource-sync-events.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
@@ -190,6 +192,14 @@ export class DaemonServer {
     }
   }
 
+  private broadcastIdentityIntroChanged(): void {
+    try {
+      publishIdentityIntroChanged();
+    } catch (err) {
+      log.error({ err }, "Failed to broadcast identity intro change");
+    }
+  }
+
   /** Best-effort sync of the IDENTITY.md name to the platform record. */
   private syncIdentityToPlatform(): void {
     try {
@@ -231,6 +241,7 @@ export class DaemonServer {
         refreshSurfacesForApp(conversation, appId, { fileChange: true });
       }
       broadcastMessage({ type: "app_files_changed", appId });
+      publishAppsChanged();
       void updatePublishedAppDeployment(appId);
     };
 
@@ -301,6 +312,7 @@ export class DaemonServer {
       () => this.broadcastAvatarUpdated(),
       () => this.broadcastConfigChanged(),
       () => refreshSkillCapabilityMemories(getConfig()),
+      () => this.broadcastIdentityIntroChanged(),
     );
 
     this.syncIdentityToPlatform();

package/src/daemon/tool-side-effects.ts

@@ -16,6 +16,7 @@ import { invalidatePageIndex } from "../memory/v2/page-index.js";
 import { getConceptsDir } from "../memory/v2/page-store.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { findActiveSession } from "../runtime/channel-verification-service.js";
+import { publishAppsChanged } from "../runtime/sync/resource-sync-events.js";
 import { deliverVerificationSlack } from "../runtime/verification-outbound-actions.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import type { ToolExecutionResult } from "../tools/types.js";
@@ -60,10 +61,15 @@ function notifyAppChanged(
   opts?: { fileChange?: boolean; status?: string },
 ): void {
   refreshSurfacesForApp(ctx, appId, opts);
-  broadcastMessage({ type: "app_files_changed", appId });
+  broadcastAppFilesChanged(appId);
   void updatePublishedAppDeployment(appId);
 }
 
+function broadcastAppFilesChanged(appId: string): void {
+  broadcastMessage({ type: "app_files_changed", appId });
+  publishAppsChanged();
+}
+
 // ── Registry ─────────────────────────────────────────────────────────
 
 /**
@@ -109,10 +115,7 @@ registerHook("app_create", (_name, _input, result, { ctx }) => {
       if (parsed.name) {
         void generateAppIcon(parsed.id, parsed.name, parsed.description)
           .then(() => {
-            broadcastMessage({
-              type: "app_files_changed",
-              appId: parsed.id!,
-            });
+            broadcastAppFilesChanged(parsed.id!);
           })
           .catch((err) => {
             log.warn(
@@ -130,14 +133,14 @@ registerHook("app_create", (_name, _input, result, { ctx }) => {
 registerHook("app_generate_icon", (_name, input) => {
   const appId = input.app_id as string | undefined;
   if (appId) {
-    broadcastMessage({ type: "app_files_changed", appId });
+    broadcastAppFilesChanged(appId);
   }
 });
 
 registerHook("app_delete", (_name, input) => {
   const appId = input.app_id as string | undefined;
   if (appId) {
-    broadcastMessage({ type: "app_files_changed", appId });
+    broadcastAppFilesChanged(appId);
   }
 });
 

package/src/daemon/trust-context.ts

@@ -49,3 +49,16 @@ export const INTERNAL_GUARDIAN_TRUST_CONTEXT = {
   sourceChannel: "vellum",
   trustClass: "guardian",
 } as const satisfies TrustContext;
+
+/**
+ * Synthetic fallback trust context used when a pipeline fires before the
+ * per-turn trust snapshot has been captured (e.g. fresh conversations before
+ * the trust resolver runs, heartbeat turns that never bind an actor, or
+ * non-turn invocations like `Conversation.forceCompact`). We bias to
+ * `unknown` rather than `guardian` so a missing snapshot cannot accidentally
+ * grant elevated trust to a custom plugin reading `ctx.trust`.
+ */
+export const FALLBACK_TURN_TRUST: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "unknown",
+};

package/src/daemon/wake-target-adapter.ts

@@ -137,6 +137,9 @@ function translateAgentEventToServerMessage(
     case "error":
     case "provider_error":
     case "max_tokens_reached":
+    case "context_compacting":
+    case "compaction_circuit_open":
+    case "compaction_circuit_closed":
     case "agent_loop_exit":
       return null;
     case "llm_call_started":
@@ -192,6 +195,13 @@ export function conversationToWakeTarget(
       conversation.processing = on;
     },
     setTrustContext: (ctx) => conversation.setTrustContext(ctx),
+    setWakeAllowedTools: (tools) => {
+      const previous = conversation.subagentAllowedTools;
+      conversation.setSubagentAllowedTools(new Set(tools));
+      return () => {
+        conversation.setSubagentAllowedTools(previous);
+      };
+    },
     persistTailMessage: async (message) => {
       const turnChannelCtx = conversation.getTurnChannelContext();
       const turnInterfaceCtx = conversation.getTurnInterfaceContext();
@@ -208,7 +218,7 @@ export function conversationToWakeTarget(
         conversation.conversationId,
         message.role,
         JSON.stringify(message.content),
-        metadata,
+        { metadata },
       );
       if (message.role === "assistant") {
         try {

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

@@ -59,7 +59,8 @@ mock.module("../../util/platform.js", () => ({
   getEmbedWorkerPidPath: () =>
     join(workspaceDir ?? fallbackDir, "embed-worker.pid"),
   getWorkspaceDirDisplay: () => workspaceDir ?? fallbackDir,
-  getWorkspaceConfigPath: () => join(workspaceDir ?? fallbackDir, "config.json"),
+  getWorkspaceConfigPath: () =>
+    join(workspaceDir ?? fallbackDir, "config.json"),
   getWorkspaceSkillsDir: () => join(workspaceDir ?? fallbackDir, "skills"),
   getWorkspaceHooksDir: () => join(workspaceDir ?? fallbackDir, ".githooks"),
   getWorkspacePluginsDir: () => join(workspaceDir ?? fallbackDir, "plugins"),
@@ -194,6 +195,7 @@ mock.module("../heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: () => 0,
   markStaleRunningAsError: () => 0,
   countCompletedHeartbeatRuns: () => 10,
+  countRecentConsecutiveRuns: () => 0,
 }));
 
 // Stub the pre-first-message gate so tests can flip it on/off without

package/src/heartbeat/heartbeat-run-store.ts

@@ -217,6 +217,37 @@ export function countCompletedHeartbeatRuns(): number {
   return row?.count ?? 0;
 }
 
+/**
+ * Count the most recent consecutive heartbeat runs with status `ok`,
+ * walking backwards from newest. Stops at the first non-`ok` status
+ * (skipped, superseded, missed, error, timeout), which acts as a
+ * natural boundary for the consecutive-run counter. In-flight rows
+ * (`pending`, `running`) are skipped so they don't break the chain.
+ *
+ * Used to restore the in-memory consecutive-run counter on startup.
+ */
+export function countRecentConsecutiveRuns(maxToCheck: number): number {
+  const db = getDb();
+  const rows = db
+    .select({ status: heartbeatRuns.status })
+    .from(heartbeatRuns)
+    .orderBy(desc(heartbeatRuns.scheduledFor))
+    .limit(maxToCheck + 5)
+    .all();
+
+  let count = 0;
+  for (const row of rows) {
+    if (row.status === "ok") {
+      count++;
+    } else if (row.status === "pending" || row.status === "running") {
+      continue;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+
 /**
  * List heartbeat runs ordered by `scheduledFor` descending.
  */

package/src/heartbeat/heartbeat-service.ts

@@ -25,6 +25,7 @@ import { stripCommentLines } from "../util/strip-comment-lines.js";
 import {
   completeHeartbeatRun,
   countCompletedHeartbeatRuns,
+  countRecentConsecutiveRuns,
   insertPendingHeartbeatRun,
   markStaleRunningAsError,
   markStaleRunsAsMissed,
@@ -176,6 +177,16 @@ export class HeartbeatService {
     return this._nextRunAt;
   }
 
+  /** Whether the consecutive-run cap has been reached. */
+  get isConsecutiveRunCapReached(): boolean {
+    const config = getConfig().heartbeat;
+    if (config.maxConsecutiveRuns == null) return false;
+    return (
+      countRecentConsecutiveRuns(config.maxConsecutiveRuns) >=
+      config.maxConsecutiveRuns
+    );
+  }
+
   async runManagedWakeIfDue(
     options: ManagedWakeHeartbeatRunOptions = {},
   ): Promise<ManagedWakeHeartbeatRunResult> {
@@ -381,6 +392,11 @@ export class HeartbeatService {
     // a stopped window still clears the count.
     this._consecutiveRuns = 0;
     this._resetGeneration++;
+    if (this._pendingRunId) {
+      supersedePendingRun(this._pendingRunId);
+      this._pendingRunId = null;
+    }
+    refreshBackgroundWakeIntentSoon("heartbeat-counter-reset");
     if (!this.timer) return;
     if (this.cronMode) {
       clearTimeout(this.timer as ReturnType<typeof setTimeout>);

package/src/home/feature-gate.ts

@@ -0,0 +1,22 @@
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../config/schema.js";
+
+const HOME_PAGE_FLAG_KEY = "home-page" as const;
+
+/**
+ * Whether the home page / home feed surface is enabled for this install.
+ *
+ * `home-page` is a `"both"`-scope flag: the client renders the home feed as the
+ * landing view, and the notification pipeline uses it to decide whether passive
+ * notifications have a home-feed surface to land on (when off, they fall back to
+ * materializing a conversation instead of being suppressed).
+ *
+ * `config` is accepted for parity with the other gate modules but is unused —
+ * the value resolves from the gateway override cache / registry default.
+ */
+export function isHomePageEnabled(config?: AssistantConfig): boolean {
+  return isAssistantFeatureFlagEnabled(
+    HOME_PAGE_FLAG_KEY,
+    (config ?? {}) as AssistantConfig,
+  );
+}