@vellumai/assistant 0.10.12 → 0.11.0-staging.1

package/src/daemon/conversation.ts

@@ -19,6 +19,7 @@ import type { AgentLoopConfig } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type { AssistantActivityStateEvent } from "../api/events/assistant-activity-state.js";
 import type { ConfirmationStateChangedEvent } from "../api/events/confirmation-state-changed.js";
+import type { AssistantEvent } from "../api/index.js";
 import { decideGuardianRequest } from "../channels/gateway-guardian-requests.js";
 import type {
   ChannelId,
@@ -125,6 +126,7 @@ import { registerConversationNotifiers } from "./conversation-notifiers.js";
 import type { ProcessMessageOptions } from "./conversation-process.js";
 import {
   drainQueue as drainQueueImpl,
+  kickQueueDrain as kickQueueDrainImpl,
   processMessage as processMessageImpl,
 } from "./conversation-process.js";
 import type {
@@ -163,11 +165,7 @@ import { canonicalizeTimeZone } from "./date-context.js";
 import { HostAppControlProxy } from "./host-app-control-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
 import { shouldAttachHostProxyForCapability } from "./host-proxy-preactivation.js";
-import type {
-  ServerMessage,
-  SurfaceType,
-  UsageStats,
-} from "./message-protocol.js";
+import type { SurfaceType, UsageStats } from "./message-protocol.js";
 import { filterMessagesForUntrustedActor } from "./message-provenance.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import { isHostProxyTransport } from "./message-types/conversations.js";
@@ -320,7 +318,7 @@ export class Conversation {
   /** @internal */ prompter: PermissionPrompter;
   /** @internal */ secretPrompter: SecretPrompter;
   private executor: ToolExecutor;
-  /** @internal */ sendToClient: (msg: ServerMessage) => void;
+  /** @internal */ sendToClient: (msg: AssistantEvent) => void;
   /** @internal */ workingDir: string;
   /** @internal */ allowedToolNames?: Set<string>;
   /**
@@ -345,6 +343,15 @@ export class Conversation {
    * @internal
    */
   subagentDenySideEffects?: boolean;
+  /**
+   * When true, mid-run subagent → parent notifications (`notify_parent`) are
+   * suppressed for this child. Set on synchronous (spawnAndAwait) subagents:
+   * the awaiting caller is their only parent channel, so injecting a
+   * user-role turn into the live parent mid-await would start an unsolicited
+   * parent run. Checked in `notifyParentFromChild`.
+   * @internal
+   */
+  subagentSuppressParentNotifications?: boolean;
   /**
    * Tool names a subagent attempted but that its role allowlist
    * ({@link subagentAllowedTools}) denied. Recorded by the tool executor;
@@ -672,7 +679,7 @@ export class Conversation {
   originChannel: ChannelId | undefined = undefined;
   /** @internal */ activityVersion = 0;
   /** Last emitted activity state message, retained for replay on SSE reconnection. */
-  /** @internal */ lastActivityStateMsg: ServerMessage | null = null;
+  /** @internal */ lastActivityStateMsg: AssistantEvent | null = null;
   /** Set by the agent loop to track confirmation outcomes for persistence. */
   onConfirmationOutcome?: (
     requestId: string,
@@ -685,7 +692,7 @@ export class Conversation {
     conversationId: string,
     provider: Provider,
     systemPrompt: string,
-    sendToClient: (msg: ServerMessage) => void,
+    sendToClient: (msg: AssistantEvent) => void,
     workingDir: string,
     options?: ConversationConstructorOptions,
   ) {
@@ -1431,7 +1438,7 @@ export class Conversation {
   }
 
   updateClient(
-    sendToClient: (msg: ServerMessage) => void,
+    sendToClient: (msg: AssistantEvent) => void,
     hasNoClient = false,
   ): void {
     this.sendToClient = sendToClient;
@@ -1453,7 +1460,7 @@ export class Conversation {
   }
 
   /** Returns the current sendToClient reference for identity comparison. */
-  getCurrentSender(): (msg: ServerMessage) => void {
+  getCurrentSender(): (msg: AssistantEvent) => void {
     return this.sendToClient;
   }
 
@@ -1465,6 +1472,10 @@ export class Conversation {
     this.subagentDenySideEffects = deny;
   }
 
+  setSubagentSuppressParentNotifications(suppress: boolean): void {
+    this.subagentSuppressParentNotifications = suppress;
+  }
+
   /**
    * Set the conversation's per-chat plugin scope, updating both the persisted
    * `enabled_plugins` row and the live instance (source of truth for the
@@ -1866,10 +1877,10 @@ export class Conversation {
   emitConfirmationStateChanged(
     params: Omit<ConfirmationStateChangedEvent, "type">,
   ): void {
-    const msg: ServerMessage = {
+    const msg: AssistantEvent = {
       type: "confirmation_state_changed",
       ...params,
-    } as ServerMessage;
+    } as AssistantEvent;
     try {
       this.sendToClient(msg);
     } catch (err) {
@@ -1891,7 +1902,7 @@ export class Conversation {
   ): void {
     const { anchor = "assistant_turn", requestId, statusText } = options ?? {};
     this.activityVersion++;
-    const msg: ServerMessage = {
+    const msg: AssistantEvent = {
       type: "assistant_activity_state",
       conversationId: this.conversationId,
       activityVersion: this.activityVersion,
@@ -1900,7 +1911,7 @@ export class Conversation {
       requestId,
       reason,
       ...(statusText ? { statusText } : {}),
-    } as ServerMessage;
+    } as AssistantEvent;
     this.lastActivityStateMsg = msg;
     try {
       this.sendToClient(msg);
@@ -2454,7 +2465,7 @@ export class Conversation {
     content: string,
     userMessageId: string,
     options?: {
-      onEvent?: (msg: ServerMessage) => void;
+      onEvent?: (msg: AssistantEvent) => void;
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
@@ -2493,6 +2504,18 @@ export class Conversation {
     return drainQueueImpl(this, reason);
   }
 
+  /**
+   * Never-rejecting drain trigger for fire-and-forget call sites. See
+   * `kickQueueDrain` in conversation-process.ts for the retry/notify
+   * semantics.
+   */
+  kickDrainQueue(
+    reason: QueueDrainReason = "loop_complete",
+    origin?: string,
+  ): Promise<void> {
+    return kickQueueDrainImpl(this, reason, origin);
+  }
+
   async processMessage(options: ProcessMessageOptions): Promise<string> {
     this.cacheWarmAbort?.abort();
     this.cacheWarmAbort = undefined;

package/src/daemon/disk-pressure-guard.ts

@@ -3,8 +3,7 @@ import {
   type DiskPressureState,
   type DiskPressureStatus,
 } from "../api/events/disk-pressure-status-changed.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { cancelBackgroundTools } from "../tools/background-tool-registry.js";
 import { getDiskUsageInfo } from "../util/disk-usage.js";
 import { getLogger } from "../util/logger.js";
@@ -107,16 +106,10 @@ function statusFingerprint(status: DiskPressureStatus): string {
 function publishStatusChangedIfNeeded(previous: DiskPressureStatus): void {
   if (statusFingerprint(previous) === statusFingerprint(state.status)) return;
   const status = cloneStatus(state.status);
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "disk_pressure_status_changed",
-        status,
-      }),
-    )
-    .catch((err) => {
-      log.warn({ err }, "Failed to publish disk pressure status change");
-    });
+  broadcastMessage({
+    type: "disk_pressure_status_changed",
+    status,
+  });
 }
 
 function replaceStatus(next: DiskPressureStatus): DiskPressureStatus {

package/src/daemon/embedding-reconcile.ts

@@ -19,7 +19,11 @@ import {
   saveRawConfig,
   setNestedValue,
 } from "../config/loader.js";
-import { isMemoryV3Live } from "../config/memory-v3-gate.js";
+import {
+  isMemoryEnabled,
+  isMemoryV2ExplicitlyDisabled,
+  isMemoryV3Live,
+} from "../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../config/types.js";
 import {
   probeBackendDimension,
@@ -30,14 +34,14 @@ import {
   enqueueMemoryJob,
   hasActiveJobOfType,
 } from "../persistence/jobs-store.js";
+import {
+  ensureConceptPageCollection,
+  recreateConceptPageCollection,
+} from "../plugins/defaults/memory/substrate/qdrant.js";
 import {
   ensureSectionCollection,
   recreateSectionCollection,
 } from "../plugins/defaults/memory/v3/section-dense-store.js";
-import {
-  ensureConceptPageCollection,
-  recreateConceptPageCollection,
-} from "../plugins/defaults/memory/v3/substrate/qdrant.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("embedding-reconcile");
@@ -157,7 +161,7 @@ async function defaultRecreateCollectionsAtDim(
  * the same type. `memory_v2_reembed` can be enqueued from two startup sites that
  * both guard on this in-flight check: the credential-arrival reconcile retry
  * (reconcile-vs-reconcile), and the lifecycle reconcile-then-rebuild interleaving
- * where `maybeRebuildMemoryV2Concepts` also enqueues a reembed when it finds the
+ * where `maybeRebuildConceptCollection` also enqueues a reembed when it finds the
  * just-(re)created collection empty. The guard keeps the corpus re-embed to a
  * single round-trip across either path.
  */
@@ -226,7 +230,7 @@ export async function reconcileEmbeddingIdentity(
   // persist/recreate/enqueue. `memory.enabled` defaults to true; gate strictly
   // on the explicit `false`. This gate covers both the lifecycle startup call
   // and the credential-arrival retry call.
-  if (config.memory.enabled === false) {
+  if (!isMemoryEnabled(config)) {
     log.info("Memory disabled — skipping embedding-identity reconcile");
     return { action: "noop", dim: null };
   }
@@ -239,8 +243,9 @@ export async function reconcileEmbeddingIdentity(
   // dimension recreate). Running here would enqueue `memory_v2_reembed` against
   // the disabled v2 index and persist a `vectorSize` after the v1 client was
   // already initialized at the old dimension. Defaults to true; gate strictly
-  // on the explicit `false` (and tolerate a missing `v2` node in test configs).
-  if (config.memory.v2?.enabled === false) {
+  // on the explicit `false` (and tolerate a missing `v2` node in test
+  // configs) — the semantics `isMemoryV2ExplicitlyDisabled` names.
+  if (isMemoryV2ExplicitlyDisabled(config)) {
     log.info(
       "Memory v2 disabled — skipping embedding-identity reconcile; v1 path owns its collection dimension",
     );

package/src/daemon/handlers/config-channels.ts

@@ -30,7 +30,6 @@ import type { ContactChannel } from "../../contacts/types.js";
 import { ipcCallPersistent } from "../../ipc/gateway-client.js";
 import { getBindingByChannelChat } from "../../persistence/external-conversation-store.js";
 import { resolveGuardianName } from "../../prompts/user-reference.js";
-import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
 import {
   type ChannelReadinessService,
@@ -42,14 +41,11 @@ import {
 } from "../../runtime/channel-verification-service.js";
 import {
   cancelOutbound,
-  deliverVerificationEmail,
   deliverVerificationSlack,
   deliverVerificationTelegram,
   DESTINATION_RATE_WINDOW_MS,
   MAX_SENDS_PER_DESTINATION_WINDOW,
   normalizeTelegramDestination,
-  resendOutbound,
-  startOutbound,
 } from "../../runtime/verification-outbound-actions.js";
 import {
   composeVerificationSlack,
@@ -58,18 +54,48 @@ import {
 } from "../../runtime/verification-templates.js";
 import { getTelegramBotUsername } from "../../telegram/bot-username.js";
 import { normalizePhoneNumber } from "../../util/phone.js";
-import type {
-  ChannelVerificationSessionRequest,
-  ChannelVerificationSessionResponse,
-} from "../message-protocol.js";
 import { log } from "./shared.js";
 
-// -- Transport-agnostic result type (omits the `type` discriminant) --
-
-export type ChannelVerificationSessionResult = Omit<
-  ChannelVerificationSessionResponse,
-  "type"
->;
+// -- Channel verification result --
+//
+// The shape returned by the verification service functions and served by the
+// HTTP channel-verification routes.
+
+export interface ChannelVerificationSessionResult {
+  success: boolean;
+  secret?: string;
+  instruction?: string;
+  /** Present when action is 'status'. */
+  bound?: boolean;
+  guardianExternalUserId?: string;
+  /** The channel this status pertains to (e.g. "telegram", "phone"). Present when action is 'status'. */
+  channel?: ChannelId;
+  /** The assistant ID scoped to this status. Present when action is 'status'. */
+  assistantId?: string;
+  /** The delivery chat ID for the guardian (e.g. Telegram chat ID). Present when action is 'status' and bound is true. */
+  guardianDeliveryChatId?: string;
+  /** Optional channel username/handle for the bound guardian (for UI display). */
+  guardianUsername?: string;
+  /** Optional display name for the bound guardian (for UI display). */
+  guardianDisplayName?: string;
+  /** Whether a pending verification challenge exists for this (assistantId, channel). Used by relay setup to detect active voice verification sessions. */
+  hasPendingChallenge?: boolean;
+  error?: string;
+  /** Human-readable error detail (e.g. for already_bound failures). */
+  message?: string;
+  /** Conversation ID for outbound verification flows. */
+  verificationSessionId?: string;
+  /** Epoch ms when the verification session expires. */
+  expiresAt?: number;
+  /** Epoch ms after which a resend is allowed. */
+  nextResendAt?: number;
+  /** Number of sends for this session. */
+  sendCount?: number;
+  /** Telegram deep-link URL for bootstrap (M3 placeholder). */
+  telegramBootstrapUrl?: string;
+  /** True when the outbound session is still in pending_bootstrap state (Telegram handle flow). Prevents the client from clearing the bootstrap URL during status polling. */
+  pendingBootstrap?: boolean;
+}
 
 // ---------------------------------------------------------------------------
 // Readiness service singleton
@@ -570,123 +596,3 @@ export async function verifyTrustedContact(
     error: `Verification is not supported for channel type "${channel.type}"`,
   };
 }
-
-// ---------------------------------------------------------------------------
-// Channel verification session handler
-// ---------------------------------------------------------------------------
-
-export async function handleChannelVerificationSession(
-  msg: ChannelVerificationSessionRequest,
-): Promise<void> {
-  const channel = msg.channel ?? "telegram";
-
-  try {
-    if (msg.action === "create_session") {
-      if (msg.purpose === "trusted_contact" && !msg.contactChannelId) {
-        broadcastMessage({
-          type: "channel_verification_session_response",
-          success: false,
-          error: "contactChannelId is required for trusted_contact purpose",
-          channel,
-        });
-      } else if (msg.purpose === "trusted_contact") {
-        const result = await verifyTrustedContact(
-          msg.contactChannelId!,
-          DAEMON_INTERNAL_ASSISTANT_ID,
-        );
-        broadcastMessage({
-          type: "channel_verification_session_response",
-          ...result,
-        });
-      } else if (msg.destination) {
-        const result = await startOutbound({
-          channel,
-          destination: msg.destination,
-          rebind: msg.rebind,
-          originConversationId: msg.originConversationId,
-        });
-        if (result._pendingSlackDm) {
-          const { userId, text, assistantId: aid } = result._pendingSlackDm;
-          deliverVerificationSlack(userId, text, aid);
-        }
-        if (result._pendingEmail) {
-          const { to, text, subject, assistantId: aid } = result._pendingEmail;
-          deliverVerificationEmail(to, text, subject, aid);
-        }
-        const {
-          _pendingSlackDm: _,
-          _pendingEmail: __,
-          ...publicResult
-        } = result;
-        broadcastMessage({
-          type: "channel_verification_session_response",
-          ...publicResult,
-        });
-      } else {
-        const result = await createInboundChallenge(
-          channel,
-          msg.rebind,
-          msg.conversationId,
-        );
-        broadcastMessage({
-          type: "channel_verification_session_response",
-          ...result,
-        });
-      }
-    } else if (msg.action === "status") {
-      const result = await getVerificationStatus(channel);
-      broadcastMessage({
-        type: "channel_verification_session_response",
-        ...result,
-      });
-    } else if (msg.action === "cancel_session") {
-      await cancelOutbound({ channel });
-      await revokePendingSessions(channel);
-      broadcastMessage({
-        type: "channel_verification_session_response",
-        success: true,
-        channel,
-      });
-    } else if (msg.action === "revoke") {
-      const result = await revokeVerificationForChannel(channel);
-      broadcastMessage({
-        type: "channel_verification_session_response",
-        ...result,
-      });
-    } else if (msg.action === "resend_session") {
-      const result = await resendOutbound({
-        channel,
-        originConversationId: msg.originConversationId,
-      });
-      if (result._pendingSlackDm) {
-        const { userId, text, assistantId: aid } = result._pendingSlackDm;
-        deliverVerificationSlack(userId, text, aid);
-      }
-      if (result._pendingEmail) {
-        const { to, text, subject, assistantId: aid } = result._pendingEmail;
-        deliverVerificationEmail(to, text, subject, aid);
-      }
-      const { _pendingSlackDm: _, _pendingEmail: __, ...publicResult } = result;
-      broadcastMessage({
-        type: "channel_verification_session_response",
-        ...publicResult,
-      });
-    } else {
-      broadcastMessage({
-        type: "channel_verification_session_response",
-        success: false,
-        error: `Unknown action: ${String(msg.action)}`,
-        channel,
-      });
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, "Failed to handle channel verification session");
-    broadcastMessage({
-      type: "channel_verification_session_response",
-      success: false,
-      error: message,
-      channel,
-    });
-  }
-}

package/src/daemon/handlers/config-model.ts

@@ -98,13 +98,21 @@ export function setImageGenModel(modelId: string, ctx: ModelSetContext): void {
   // Keep the derived provider in sync with the selected model so downstream
   // routing never sends a Gemini request to an OpenAI model (or vice versa).
   // The prefix logic is shared with workspace migration 006-services-config
-  // via providerForImageModelPrefix().
-  setServiceField(
-    raw,
-    "image-generation",
-    "provider",
-    providerForImageModelPrefix(modelId),
-  );
+  // via providerForImageModelPrefix(). Provider "vellum" is exempt: it is
+  // managed for every model (the backend derives from the model at request
+  // time), and rewriting it here would silently move a managed user onto a
+  // BYOK provider they may hold no key for.
+  const services = raw.services as
+    | Record<string, { provider?: string }>
+    | undefined;
+  if (services?.["image-generation"]?.provider !== "vellum") {
+    setServiceField(
+      raw,
+      "image-generation",
+      "provider",
+      providerForImageModelPrefix(modelId),
+    );
+  }
 
   const wasSuppressed = ctx.suppressConfigReload;
   ctx.setSuppressConfigReload(true);

package/src/daemon/handlers/conversations.ts

@@ -103,10 +103,12 @@ export function cancelGeneration(conversationId: string): boolean {
   conversation.abort(
     createAbortReason("user_cancel", "cancelGeneration", conversationId),
   );
-  // Also abort any child subagents spawned by this conversation.
+  // Also abort any in-flight child subagents spawned by this conversation.
   // Omit sendToClient to suppress parent notifications — the parent is
   // being cancelled, so enqueuing synthetic messages would trigger
-  // unwanted model activity after the user pressed stop.
+  // unwanted model activity after the user pressed stop. Terminal children
+  // stay readable: the conversation survives the stop, and its next turn may
+  // still `subagent_read` a completed child's result.
   getSubagentManager().abortAllForParent(conversationId);
   // Cancel any in-flight ACP agent sessions this conversation spawned, for the
   // same reason: a backgrounded ACP prompt would otherwise keep running (and

package/src/daemon/handlers/shared.ts

@@ -98,6 +98,26 @@ export interface RenderedHistoryContent {
   contentBlocks: ConversationContentBlock[];
 }
 
+/**
+ * One entry from Slack's `app_context` — an object the sender had open in
+ * Slack when they sent the message. `value` is an id string for the channel /
+ * canvas / list entity types and an object for `slack#/types/message_context`,
+ * which points at a specific message. Mirrors `sourceMetadata.appContext` on
+ * the gateway inbound contract; the values arrive unvalidated, so every
+ * consumer shape-checks before use.
+ */
+export interface SlackAppContextEntity {
+  type: string;
+  value: string | { messageTs?: string; channelId?: string };
+  teamId?: string;
+  enterpriseId?: string;
+}
+
+/** The sender's active Slack context for a single inbound message. */
+export interface SlackAppContext {
+  entities: SlackAppContextEntity[];
+}
+
 /**
  * Slack-specific metadata extracted at the inbound HTTP boundary and threaded
  * through to user-message persistence so the row can be tagged with a
@@ -130,6 +150,15 @@ export interface SlackInboundMessageMetadata {
   timestampTimezoneLabel?: string;
   /** Compact timezone label appended to the rendered speaker name. */
   speakerTimezoneLabel?: string;
+  /**
+   * What the sender had open in Slack when they sent this message. Carried
+   * here so it lands on the stored ingress payload alongside the rest of
+   * `slackInbound`, letting the retry sweep render a replayed turn with the
+   * same context the live turn saw. Not projected into `slackMeta`: the
+   * context is baked into the message content at ingress, so the transcript
+   * renderer already has it.
+   */
+  appContext?: SlackAppContext;
 }
 
 /**

package/src/daemon/host-proxy-base.ts

@@ -15,6 +15,7 @@
  */
 import { v4 as uuid } from "uuid";
 
+import type { AssistantEvent } from "../api/index.js";
 import type { HostProxyCapability } from "../channels/types.js";
 import {
   assistantEventHub,
@@ -24,23 +25,22 @@ import type { PendingInteraction } from "../runtime/pending-interactions.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
-import type { ServerMessage } from "./message-protocol.js";
 
 const log = getLogger("host-proxy-base");
 
 /**
  * `broadcastMessage` is statically typed against the discriminated
- * `ServerMessage` union. The base class assembles envelopes from
+ * `AssistantEvent` union. The base class assembles envelopes from
  * constructor-supplied event names and untyped extra fields, so static
  * narrowing is impossible — subclasses are responsible for passing event
- * names that match a real `ServerMessage` variant.
+ * names that match a real `AssistantEvent` variant.
  */
 function broadcastDynamic(
   envelope: Record<string, unknown>,
   targetClientId?: string,
 ): void {
   broadcastMessage(
-    envelope as unknown as ServerMessage,
+    envelope as unknown as AssistantEvent,
     undefined,
     targetClientId ? { targetClientId } : undefined,
   );

package/src/daemon/lifecycle.ts

@@ -27,6 +27,7 @@ import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { startEmbeddingRuntimeManager } from "../persistence/embeddings/embedding-backend.js";
 import { maybeEnqueueLexicalBackfillOnUpgrade } from "../persistence/job-handlers/message-lexical-backfill.js";
+import { clearLifecycleQuiesce } from "../persistence/lifecycle-quiesce.js";
 import { startConsentRefresh } from "../platform/consent-cache.js";
 import { syncWorkspaceIdentityToPlatform } from "../platform/sync-identity.js";
 import { ensurePromptFiles } from "../prompts/system-prompt.js";
@@ -45,6 +46,7 @@ import {
 } from "../runtime/http-server.js";
 import { warmLocalGuardianPrincipalCache } from "../runtime/local-actor-identity.js";
 import { recoverInterruptedImport } from "../runtime/migrations/vbundle-streaming-importer.js";
+import { markCurrentProcessAsMainDaemon } from "../runtime/process-role.js";
 import { publishConfigChanged } from "../runtime/sync/resource-sync-events.js";
 import { recoverStaleSchedules } from "../schedule/schedule-recovery.js";
 import { startScheduler } from "../schedule/scheduler.js";
@@ -103,6 +105,11 @@ function loadDotEnv(): void {
 
 // Entry point for the daemon process itself
 export async function runDaemon(): Promise<void> {
+  // Identify this process as the daemon before anything can publish: it owns
+  // the event hub real clients subscribe to, so plugin-facing publishes made
+  // here fan out locally rather than routing to a daemon over IPC.
+  markCurrentProcessAsMainDaemon();
+
   const startupStartedAt = Date.now();
   // dotenv loads before the first log call so the lazy root logger
   // initializes against the final VELLUM_WORKSPACE_DIR / log path, not
@@ -242,6 +249,12 @@ export async function runDaemon(): Promise<void> {
   try {
     const { migrationsOk } = await initializeDb();
     dbReady = true;
+    // A quiesce lease can survive a stop that happened mid-drain; clear it so
+    // a fresh boot never starts with background work paused. Placed
+    // synchronously after DB init — before any await yields to the
+    // already-listening HTTP server — so it cannot delete a lease a client
+    // arms against THIS boot.
+    clearLifecycleQuiesce();
     // Floor the stream seq counter above every persisted conversation
     // anchor before turns can stamp events. Anchors are getCurrentSeq()
     // snapshots already served to clients, and a crashed process can have