@vellumai/assistant 0.8.5 → 0.8.7

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

@@ -1,5 +1,7 @@
 // Workspace file, identity, and tool permission types.
 
+import type { IdentityChangedEvent } from "../../api/events/identity-changed.js";
+
 // === Client → Server ===
 
 export interface WorkspaceFilesListRequest {
@@ -117,16 +119,6 @@ export interface ToolNamesListResponse {
   schemas?: Record<string, ToolInputSchema>;
 }
 
-/** Server push — broadcast when IDENTITY.md changes on disk. */
-export interface IdentityChanged {
-  type: "identity_changed";
-  name: string;
-  role: string;
-  personality: string;
-  emoji: string;
-  home: string;
-}
-
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
 export type _WorkspaceClientMessages =
@@ -142,4 +134,4 @@ export type _WorkspaceServerMessages =
   | IdentityGetResponse
   | ToolPermissionSimulateResponse
   | ToolNamesListResponse
-  | IdentityChanged;
+  | IdentityChangedEvent;

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);
@@ -508,13 +516,13 @@ export async function processMessage(
   const persistMetadata = options?.slackInbound
     ? { slackInbound: options.slackInbound }
     : undefined;
-  const messageId = await conversation.persistUserMessage(
-    resolvedContent,
+  const { id: messageId } = await conversation.persistUserMessage({
+    content: resolvedContent,
     attachments,
     requestId,
-    persistMetadata,
-    options?.displayContent,
-  );
+    metadata: persistMetadata,
+    displayContent: options?.displayContent,
+  });
   publishConversationMessagesChanged(conversationId);
 
   if (options?.isInteractive === true) {
@@ -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);
 
@@ -571,13 +573,13 @@ export async function processMessageInBackground(
   const persistMetadata = options?.slackInbound
     ? { slackInbound: options.slackInbound }
     : undefined;
-  const messageId = await conversation.persistUserMessage(
+  const { id: messageId } = await conversation.persistUserMessage({
     content,
     attachments,
     requestId,
-    persistMetadata,
-    options?.displayContent,
-  );
+    metadata: persistMetadata,
+    displayContent: options?.displayContent,
+  });
   publishConversationMessagesChanged(conversationId);
 
   if (options?.isInteractive === true) {
@@ -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/providers-setup.ts

@@ -133,7 +133,7 @@ export async function initializeProvidersAndTools(
           serverConfig,
           manager,
         );
-        registerMcpTools(mcpTools);
+        registerMcpTools(serverId, mcpTools);
       }
     } catch (err) {
       log.error(

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";
@@ -50,6 +52,15 @@ import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
 
 const log = getLogger("server");
 
+function isEaddrInUse(err: unknown): boolean {
+  return (
+    typeof err === "object" &&
+    err !== null &&
+    "code" in err &&
+    (err as NodeJS.ErrnoException).code === "EADDRINUSE"
+  );
+}
+
 function readPackageVersion(): string | undefined {
   try {
     const pkgPath = join(import.meta.dir, "../../package.json");
@@ -181,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 {
@@ -222,6 +241,7 @@ export class DaemonServer {
         refreshSurfacesForApp(conversation, appId, { fileChange: true });
       }
       broadcastMessage({ type: "app_files_changed", appId });
+      publishAppsChanged();
       void updatePublishedAppDeployment(appId);
     };
 
@@ -259,6 +279,13 @@ export class DaemonServer {
     try {
       await this.cliIpc.start();
     } catch (err) {
+      if (isEaddrInUse(err)) {
+        log.error(
+          { err },
+          "CLI IPC socket already in use by another daemon — aborting startup to prevent duplicate processing",
+        );
+        throw err;
+      }
       log.warn(
         { err },
         "CLI IPC server failed to start — continuing startup with degraded CLI connectivity",
@@ -285,6 +312,7 @@ export class DaemonServer {
       () => this.broadcastAvatarUpdated(),
       () => this.broadcastConfigChanged(),
       () => refreshSkillCapabilityMemories(getConfig()),
+      () => this.broadcastIdentityIntroChanged(),
     );
 
     this.syncIdentityToPlatform();

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

@@ -1,4 +1,5 @@
 import type { ProfileEntry } from "../config/schemas/llm.js";
+import { AUTO_PROFILE_KEY } from "../config/seed-inference-profiles.js";
 import type { ToolDefinition } from "../providers/types.js";
 
 export const SWITCH_INFERENCE_PROFILE_TOOL_NAME = "switch_inference_profile";
@@ -16,7 +17,13 @@ export function buildSwitchInferenceProfileToolDef(
   currentProfile?: string,
 ): ToolDefinition | null {
   const entries = Object.entries(profiles).filter(
-    ([, entry]) => entry.status !== "disabled",
+    ([key, entry]) =>
+      entry.status !== "disabled" &&
+      key !== AUTO_PROFILE_KEY &&
+      // Mix profiles are A/B-routing buckets, not concrete targets the model
+      // should self-select into — exclude them so the picker only offers real
+      // profiles.
+      entry.mix == null,
   );
   if (entries.length < 2) return null;
 
@@ -32,11 +39,14 @@ export function buildSwitchInferenceProfileToolDef(
     .join("\n");
 
   const currentEntry = currentProfile ? profiles[currentProfile] : undefined;
-  const currentLabel = currentEntry?.label ?? currentProfile ?? "current";
+  const currentLabel =
+    currentProfile === AUTO_PROFILE_KEY
+      ? "Auto (starting on Balanced)"
+      : (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}`,
+    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 — AND you MUST also call it when the query is trivially simple and a faster, cheaper profile would handle it equally well.\n\nSwitch UP (to a more capable profile) for: multi-step reasoning or analysis, math proofs or derivations, complex coding tasks, detailed creative writing, or any task requiring deep thought.\n\nSwitch DOWN (to a faster profile) for: simple greetings or chitchat, one-word or single-sentence answers, factual lookups, acknowledgments, or any query that does not benefit from advanced reasoning.\n\nWhen in doubt about whether you can handle the query well, switch UP. When in doubt about whether the query is too simple for your current profile, switch DOWN.\n\nAvailable profiles:\n${profileDescriptions}`,
     input_schema: {
       type: "object" as const,
       properties: {

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

@@ -64,10 +64,4 @@ export interface ToolSetupContext extends SurfaceConversationContext {
    * 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/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

@@ -136,8 +136,21 @@ function translateAgentEventToServerMessage(
     case "usage":
     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":
+      // The wake path persists its assistant tail via `persistTailMessage`
+      // (an `addMessage`-shaped call below) rather than via the main
+      // event-handler's `reserve` → `updateContent` pipeline, so there is
+      // no row to reserve here. Translation returns null and the wake
+      // path's existing end-of-turn persist continues to mint the row.
+      // Following up with full wake-path pre-allocation parity is tracked
+      // as a B3 follow-up.
+      return null;
   }
 }
 
@@ -182,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();
@@ -198,7 +218,7 @@ export function conversationToWakeTarget(
         conversation.conversationId,
         message.role,
         JSON.stringify(message.content),
-        metadata,
+        { metadata },
       );
       if (message.role === "assistant") {
         try {

package/src/documents/document-store.ts

@@ -217,6 +217,44 @@ export function searchDocumentsByTitle(
   }
 }
 
+/**
+ * Return the most recent empty document in the given conversation with the
+ * supplied title, created within the last `withinMs` milliseconds.
+ *
+ * Used to dedupe a duplicate create-then-create flow after a failed update —
+ * when the model can't recover a malformed update and retries by creating a
+ * second same-title document, we reuse the first (still-empty) draft instead
+ * of producing a duplicate row. Returns `null` when no candidate exists.
+ */
+export function findRecentEmptyDocumentByTitle(
+  conversationId: string,
+  title: string,
+  withinMs: number,
+): { surfaceId: string } | null {
+  try {
+    const threshold = Date.now() - withinMs;
+    const row = rawGet<{ surface_id: string }>(
+      /*sql*/ `SELECT surface_id FROM documents
+       WHERE conversation_id = ?
+         AND title = ?
+         AND content = ''
+         AND created_at >= ?
+       ORDER BY created_at DESC
+       LIMIT 1`,
+      conversationId,
+      title,
+      threshold,
+    );
+    return row ? { surfaceId: row.surface_id } : null;
+  } catch (error) {
+    log.error(
+      { err: error, conversationId, title },
+      "Find-recent-empty-document error",
+    );
+    return null;
+  }
+}
+
 /**
  * Delete a document and its conversation associations.
  * Returns `true` if the document existed and was deleted, `false` otherwise.

package/src/export/__tests__/transcript-formatter.test.ts

@@ -76,6 +76,7 @@ mock.module("../../memory/conversation-crud.js", () => ({
   getMessages: (id: string) =>
     id === "child-conv-1" ? childMessages : parentMessages,
   messageMetadataSchema,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../../util/truncate.js", () => ({

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

@@ -43,6 +43,36 @@ mock.module("../../util/platform.js", () => ({
     join(workspaceDir ?? fallbackDir, "avatar/avatar-image.png"),
 
   getXdgVellumConfigDirName: () => ".vellum",
+  getPidPath: () => join(workspaceDir ?? fallbackDir, "assistant.pid"),
+  getDbPath: () => join(workspaceDir ?? fallbackDir, "db/assistant.db"),
+  getLogsDir: () => join(workspaceDir ?? fallbackDir, "logs"),
+  getHistoryPath: () => join(workspaceDir ?? fallbackDir, "history.json"),
+  getProtectedDir: () => join(workspaceDir ?? fallbackDir, "protected"),
+  getSignalsDir: () => join(workspaceDir ?? fallbackDir, "signals"),
+  getDaemonStderrLogPath: () =>
+    join(workspaceDir ?? fallbackDir, "logs/assistant.err.log"),
+  getDaemonStartupLockPath: () =>
+    join(workspaceDir ?? fallbackDir, "assistant.lock"),
+  getExternalDir: () => join(workspaceDir ?? fallbackDir, "external"),
+  getBinDir: () => join(workspaceDir ?? fallbackDir, "bin"),
+  getDotEnvPath: () => join(workspaceDir ?? fallbackDir, ".env"),
+  getEmbedWorkerPidPath: () =>
+    join(workspaceDir ?? fallbackDir, "embed-worker.pid"),
+  getWorkspaceDirDisplay: () => workspaceDir ?? fallbackDir,
+  getWorkspaceConfigPath: () =>
+    join(workspaceDir ?? fallbackDir, "config.json"),
+  getWorkspaceSkillsDir: () => join(workspaceDir ?? fallbackDir, "skills"),
+  getWorkspaceHooksDir: () => join(workspaceDir ?? fallbackDir, ".githooks"),
+  getWorkspacePluginsDir: () => join(workspaceDir ?? fallbackDir, "plugins"),
+  getWorkspaceRoutesDir: () => join(workspaceDir ?? fallbackDir, "routes"),
+  getDeprecatedDir: () => join(workspaceDir ?? fallbackDir, "deprecated"),
+  getProfilerRootDir: () => join(workspaceDir ?? fallbackDir, "profiler"),
+  getProfilerRunsDir: () => join(workspaceDir ?? fallbackDir, "profiler/runs"),
+  getProfilerRunDir: (runId: string) =>
+    join(workspaceDir ?? fallbackDir, "profiler/runs", runId),
+  getSkillRuntimePath: () => join(workspaceDir ?? fallbackDir, "skill-runtime"),
+  getBundledBunPath: () => undefined,
+  ensureDataDir: () => {},
 }));
 
 // Stub config so heartbeat is enabled. Must export every symbol from
@@ -165,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.
  */