@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

package/src/daemon/conversation-runtime-assembly.ts

@@ -29,6 +29,7 @@ import {
   extractMemoryPrefixBlocks,
   stripAllMemoryInjections,
 } from "../memory/graph/conversation-graph-memory.js";
+import { MEMORY_V3_BLOCK_ID } from "../memory/v3/types.js";
 import {
   readSlackMetadata,
   readSlackMetadataFromMessageMetadata,
@@ -42,8 +43,8 @@ import {
   renderSlackTranscriptWithProvenance,
 } from "../messaging/providers/slack/render-transcript.js";
 import { getInjectorChain } from "../plugins/defaults/memory-retrieval/injector-chain.js";
-import { MEMORY_V3_BLOCK_ID } from "../plugins/defaults/memory-v3-shadow/types.js";
 import type {
+  DiskPressureInjectionContext,
   InjectionBlock,
   InjectionPlacement,
   TurnContext,
@@ -59,7 +60,6 @@ import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/ac
 import type { SubagentState } from "../subagent/types.js";
 import { TERMINAL_STATUSES } from "../subagent/types.js";
 import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
-import { findConversationOrSubagent } from "./conversation-registry.js";
 import type {
   DynamicPageSurfaceData,
   SurfaceData,
@@ -270,8 +270,8 @@ export function isGroupChatType(chatType?: string): boolean {
   }
 }
 
-/** Context about the active workspace surface, rendered into the `<active_workspace>` block. */
-interface ActiveSurfaceContext {
+/** Context about the active workspace surface, passed to applyRuntimeInjections. */
+export interface ActiveSurfaceContext {
   surfaceId: string;
   html: string;
   /** When set, the surface is backed by a persisted app. */
@@ -352,6 +352,24 @@ export function buildActiveDocuments(conversationId: string): Array<{
     : null;
 }
 
+/**
+ * Resolves the `<workspace>` top-level block for the runtime injector, or
+ * `null` when the turn isn't injecting it. The refresh runs every turn so a
+ * workspace-mutating tool's `markWorkspaceTopLevelDirty` is picked up on the
+ * following turn; it is dirty-guarded, so it only rescans when the cache is
+ * stale.
+ */
+export function buildWorkspaceTopLevelContext(
+  ctx: {
+    refreshWorkspaceTopLevelContextIfNeeded(): void;
+    workspaceTopLevelContext: string | null;
+  },
+  shouldInject: boolean,
+): string | null {
+  ctx.refreshWorkspaceTopLevelContextIfNeeded();
+  return shouldInject ? ctx.workspaceTopLevelContext : null;
+}
+
 const MAX_CONTEXT_LENGTH = 100_000;
 
 function truncateHtml(html: string, budget: number): string {
@@ -567,7 +585,7 @@ export function buildSubagentStatusBlock(
 }
 
 // The `<active_subagents>` block is emitted by the `subagent-status` default
-// injector (`plugins/defaults/memory-retrieval/injectors.ts`) as an `append-user-tail`
+// injector (`plugins/defaults/injectors/register.ts`) as an `append-user-tail`
 // placement. Use {@link applyRuntimeInjections} with
 // `options.subagentStatusBlock` set, or drive the injector chain directly
 // via `collectInjectorBlocks`.
@@ -1822,19 +1840,25 @@ function applyInjectionBlock(
  * bag attached to the {@link TurnContext} the caller provides (or to an
  * ephemeral {@link TurnContext} synthesized for test call sites). A small
  * number of fields drive hardcoded branches that live outside the injector
- * chain — `isNonInteractive` — because it is orchestrator-owned content that
- * never made sense as a plugin-overridable default injector.
- *
- * The active workspace surface, the channel capabilities, the active document
- * list, the channel command context, the voice call-control prompt, and the
- * transport hints are not on this bag: `applyRuntimeInjections` resolves them
- * from the live conversation itself (its surface state, `channelCapabilities`,
- * the document store keyed by `conversationId`, its `commandIntent`, its
- * `voiceCallControlPrompt`, and its `transportHints` respectively), so the
- * orchestrator does not compute or thread them per turn.
+ * chain — `activeSurface`, `channelCapabilities`, `channelCommandContext`,
+ * `voiceCallControlPrompt`, `transportHints`, and `isNonInteractive` —
+ * because they are orchestrator-owned content that never made sense as
+ * plugin-overridable default injectors.
  */
 export interface RuntimeInjectionOptions {
+  diskPressureContext?: DiskPressureInjectionContext | null;
+  /**
+   * Active dashboard-surface context (read from `<active_workspace>`). Kept
+   * on the options bag rather than an injector because it is a
+   * channel-capability concern that has never been gated as a default
+   * injector.
+   */
+  activeSurface?: ActiveSurfaceContext | null;
+  workspaceTopLevelContext?: string | null;
+  channelCapabilities?: ChannelCapabilities | null;
+  channelCommandContext?: ChannelCommandContext | null;
   unifiedTurnContext?: string | null;
+  voiceCallControlPrompt?: string | null;
   subagentStatusBlock?: string | null;
   isNonInteractive?: boolean;
   /**
@@ -1844,6 +1868,7 @@ export interface RuntimeInjectionOptions {
    * configured reminder.
    */
   isBackgroundConversation?: boolean;
+  transportHints?: string[] | null;
   /**
    * Pre-rendered Slack chronological transcript that replaces the
    * default `runMessages` history for any Slack conversation (channels
@@ -1878,6 +1903,7 @@ export interface RuntimeInjectionOptions {
    * `undefined` when the inbound is a top-level (non-thread) post.
    */
   slackActiveThreadFocusBlock?: string | null;
+  activeDocuments?: TurnInjectionInputs["activeDocuments"];
   mode?: InjectionMode;
   /**
    * Per-turn {@link TurnContext} forwarded to plugin-registered
@@ -1905,35 +1931,33 @@ export interface RuntimeInjectionOptions {
  */
 function buildTurnInjectionInputs(
   options: RuntimeInjectionOptions,
-  channelCapabilities: ChannelCapabilities | null,
-  activeDocuments: TurnInjectionInputs["activeDocuments"],
 ): TurnInjectionInputs {
   return {
     mode: options.mode,
+    diskPressureContext: options.diskPressureContext,
+    workspaceTopLevelContext: options.workspaceTopLevelContext,
     unifiedTurnContext: options.unifiedTurnContext,
     subagentStatusBlock: options.subagentStatusBlock,
-    channelCapabilities,
+    channelCapabilities: options.channelCapabilities,
     slackChronologicalMessages: options.slackChronologicalMessages,
     slackActiveThreadFocusBlock: options.slackActiveThreadFocusBlock,
+    activeSurface: options.activeSurface,
+    channelCommandContext: options.channelCommandContext,
+    voiceCallControlPrompt: options.voiceCallControlPrompt,
+    transportHints: options.transportHints,
     isNonInteractive: options.isNonInteractive,
     isBackgroundConversation: options.isBackgroundConversation,
-    activeDocuments,
+    activeDocuments: options.activeDocuments,
   };
 }
 
-/**
- * Conversation id used for the synthetic fallback {@link TurnContext} and the
- * live-conversation lookup when the caller omits a context (test call sites).
- */
-const RUNTIME_ASSEMBLY_FALLBACK_CONVERSATION_ID = "runtime-assembly-fallback";
-
 /** Minimal synthetic TurnContext used when the caller omits one. */
 function synthesizeFallbackTurnContext(
   inputs: TurnInjectionInputs,
 ): TurnContext {
   return {
-    requestId: RUNTIME_ASSEMBLY_FALLBACK_CONVERSATION_ID,
-    conversationId: RUNTIME_ASSEMBLY_FALLBACK_CONVERSATION_ID,
+    requestId: "runtime-assembly-fallback",
+    conversationId: "runtime-assembly-fallback",
     turnIndex: 0,
     trust: {
       sourceChannel: inputs.channelCapabilities?.channel
@@ -1974,9 +1998,6 @@ function synthesizeFallbackTurnContext(
  *  6. Run the remaining hardcoded branches (`isNonInteractive`,
  *     `voiceCallControlPrompt`, `activeSurface`, `channelCapabilities`,
  *     `channelCommandContext`, `transportHints`) in their historical order.
- *     `voiceCallControlPrompt`, `activeSurface`, `channelCapabilities`,
- *     `channelCommandContext`, and `transportHints` are sourced from the live
- *     conversation rather than `options`.
  *  7. Finally, apply the chain's remaining blocks by placement:
  *     `"append-user-tail"` in ascending `order`, then `"prepend-user-tail"`
  *     in descending `order` so the lowest-`order` prepend lands topmost in
@@ -1991,58 +2012,14 @@ export async function applyRuntimeInjections(
   options: RuntimeInjectionOptions,
 ): Promise<RuntimeInjectionResult> {
   const mode = options.mode ?? "full";
-
-  // Source the channel capabilities from the live conversation rather than a
-  // per-turn option computed by the orchestrator. The same value drives the
-  // Slack-conversation gate, the `<channel_capabilities>` branch, and the
-  // per-injector inputs the Slack injectors read.
-  const conversationId =
-    options.turnContext?.conversationId ??
-    RUNTIME_ASSEMBLY_FALLBACK_CONVERSATION_ID;
-  const channelCapabilities =
-    findConversationOrSubagent(conversationId)?.channelCapabilities ?? null;
-  const slackConversation = channelCapabilities?.channel === "slack";
-
-  // Source the active documents from the document store keyed by the same
-  // conversation id rather than a per-turn option computed by the
-  // orchestrator; the `active-documents` and `document-comments` injectors
-  // read the result off their per-injector inputs.
-  const activeDocuments = buildActiveDocuments(conversationId);
-
-  // Source the channel command intent (e.g. Telegram /start) from the live
-  // conversation rather than a per-turn option. It is set on the conversation
-  // at message-processing start and cleared at turn end, so the same value
-  // drives the `<channel_command_context>` branch on every assembly call
-  // within the turn.
-  const channelCommandContext =
-    findConversationOrSubagent(conversationId)?.commandIntent ?? null;
-
-  // Source the voice call-control prompt from the live conversation rather
-  // than a per-turn option. The voice-session bridge sets it on the
-  // conversation when a call attaches and clears it when the call ends, so
-  // the same value drives the `<voice_call_control>` branch on every assembly
-  // call within the turn.
-  const voiceCallControlPrompt =
-    findConversationOrSubagent(conversationId)?.voiceCallControlPrompt ?? null;
-
-  // Source the transport hints from the live conversation rather than a
-  // per-turn option. They are set on the conversation from the inbound
-  // message's transport when the message is processed, so the same value
-  // drives the `<transport_hints>` branch on every assembly call within the
-  // turn.
-  const transportHints =
-    findConversationOrSubagent(conversationId)?.transportHints ?? null;
+  const slackConversation = options.channelCapabilities?.channel === "slack";
 
   // Build the per-injector inputs and attach them to the caller's
   // TurnContext (without mutating it). When the caller didn't supply one,
   // synthesize a minimal fallback so the chain still runs — test call sites
   // that drive injection via `options` without constructing a full context
   // continue to work.
-  const injectionInputs = buildTurnInjectionInputs(
-    options,
-    channelCapabilities,
-    activeDocuments,
-  );
+  const injectionInputs = buildTurnInjectionInputs(options);
   const turnCtx: TurnContext = options.turnContext
     ? { ...options.turnContext, injectionInputs }
     : synthesizeFallbackTurnContext(injectionInputs);
@@ -2216,56 +2193,42 @@ export async function applyRuntimeInjections(
     }
   }
 
-  if (voiceCallControlPrompt) {
+  if (options.voiceCallControlPrompt) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectVoiceCallControlContext(userTail, voiceCallControlPrompt),
+        injectVoiceCallControlContext(userTail, options.voiceCallControlPrompt),
       ];
     }
   }
 
-  if (mode === "full") {
-    // Source the active workspace surface from the live conversation's surface
-    // state rather than from a per-turn option computed by the orchestrator.
-    const surfaceConversation = findConversationOrSubagent(
-      turnCtx.conversationId,
-    );
-    const activeSurface = surfaceConversation
-      ? buildActiveSurfaceContext({
-          currentActiveSurfaceId: surfaceConversation.currentActiveSurfaceId,
-          currentPage: surfaceConversation.currentPage,
-          surfaceState: surfaceConversation.surfaceState,
-        })
-      : null;
-    if (activeSurface) {
-      const userTail = result[result.length - 1];
-      if (userTail && userTail.role === "user") {
-        result = [
-          ...result.slice(0, -1),
-          injectActiveSurfaceContext(userTail, activeSurface),
-        ];
-      }
+  if (mode === "full" && options.activeSurface) {
+    const userTail = result[result.length - 1];
+    if (userTail && userTail.role === "user") {
+      result = [
+        ...result.slice(0, -1),
+        injectActiveSurfaceContext(userTail, options.activeSurface),
+      ];
     }
   }
 
-  if (channelCapabilities) {
+  if (options.channelCapabilities) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectChannelCapabilityContext(userTail, channelCapabilities),
+        injectChannelCapabilityContext(userTail, options.channelCapabilities),
       ];
     }
   }
 
-  if (mode === "full" && channelCommandContext) {
+  if (mode === "full" && options.channelCommandContext) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectChannelCommandContext(userTail, channelCommandContext),
+        injectChannelCommandContext(userTail, options.channelCommandContext),
       ];
     }
   }
@@ -2279,14 +2242,14 @@ export async function applyRuntimeInjections(
   if (
     mode === "full" &&
     !slackConversation &&
-    transportHints &&
-    transportHints.length > 0
+    options.transportHints &&
+    options.transportHints.length > 0
   ) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
         ...result.slice(0, -1),
-        injectTransportHints(userTail, transportHints),
+        injectTransportHints(userTail, options.transportHints),
       ];
     }
   }

package/src/daemon/conversation-store.ts

@@ -27,18 +27,99 @@ import { ProviderNotConfiguredError } from "../util/errors.js";
 import { getSandboxWorkingDir } from "../util/platform.js";
 import { Conversation } from "./conversation.js";
 import type { ConversationEvictor } from "./conversation-evictor.js";
-import {
-  allConversations,
-  clearConversations,
-  conversationCount,
-  conversationIds,
-  deleteConversation,
-  findConversation,
-  setConversation,
-} from "./conversation-registry.js";
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { buildTransportHints } from "./transport-hints.js";
 
+// ── Private store ──────────────────────────────────────────────────
+
+const conversations = new Map<string, Conversation>();
+
+// ── Read helpers ───────────────────────────────────────────────────
+
+export function findConversation(
+  conversationId: string,
+): Conversation | undefined {
+  return conversations.get(conversationId);
+}
+
+export function findConversationBySurfaceId(
+  surfaceId: string,
+): Conversation | undefined {
+  // Fast path: exact surfaceId match in surfaceState
+  for (const c of conversations.values()) {
+    if (c.surfaceState.has(surfaceId)) return c;
+  }
+
+  // Fallback: standalone app surfaces use "app-open-{appId}" IDs that
+  // were never part of any conversation.  Extract the appId and find
+  // a conversation whose surfaceState has a surface for that app.
+  const appOpenPrefix = "app-open-";
+  if (surfaceId.startsWith(appOpenPrefix)) {
+    const appId = surfaceId.slice(appOpenPrefix.length);
+    for (const c of conversations.values()) {
+      for (const [, state] of c.surfaceState.entries()) {
+        const data = state.data as unknown as Record<string, unknown>;
+        if (data?.appId === appId) {
+          // Register this surfaceId so subsequent lookups are O(1)
+          c.surfaceState.set(surfaceId, state);
+          return c;
+        }
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function conversationCount(): number {
+  return conversations.size;
+}
+
+/** Iterate over all active conversations. */
+export function allConversations(): IterableIterator<Conversation> {
+  return conversations.values();
+}
+
+/** Iterate over all [id, conversation] entries. */
+export function conversationEntries(): IterableIterator<
+  [string, Conversation]
+> {
+  return conversations.entries();
+}
+
+/** Iterate over all active conversation IDs. */
+function conversationIds(): IterableIterator<string> {
+  return conversations.keys();
+}
+
+// ── Write helpers ──────────────────────────────────────────────────
+
+export function setConversation(
+  conversationId: string,
+  conversation: Conversation,
+): void {
+  conversations.set(conversationId, conversation);
+}
+
+export function deleteConversation(conversationId: string): boolean {
+  return conversations.delete(conversationId);
+}
+
+export function clearConversations(): void {
+  conversations.clear();
+}
+
+// ── Underlying Map (for the evictor, which takes a mutable ref) ───
+
+/**
+ * Expose the raw Map for the {@link ConversationEvictor}, which needs
+ * a mutable reference to delete entries during sweeps. No other code
+ * should use this — prefer the named helpers above.
+ */
+export function getConversationMap(): Map<string, Conversation> {
+  return conversations;
+}
+
 // ── Per-conversation persistent options ────────────────────────────
 
 const conversationOptions = new Map<string, ConversationCreateOptions>();

package/src/daemon/conversation-workspace.ts

@@ -4,7 +4,6 @@ import { getConversation } from "../memory/conversation-crud.js";
 import { resolveConversationDirectoryPaths } from "../memory/conversation-directories.js";
 import { renderWorkspaceTopLevelContext } from "../workspace/top-level-renderer.js";
 import { scanTopLevelDirectories } from "../workspace/top-level-scanner.js";
-import { findConversationOrSubagent } from "./conversation-registry.js";
 
 /**
  * Subset of Conversation state that workspace context helpers need.
@@ -26,22 +25,6 @@ export interface WorkspaceConversationContext {
   hostUsername?: string;
 }
 
-/**
- * Resolve the live workspace top-level block for a conversation, refreshing
- * the dirty-guarded cache first so a workspace-mutating tool's
- * `markWorkspaceTopLevelDirty` from the prior turn is picked up. Returns `null`
- * when no live conversation is found (no active conversation, or a context with
- * no conversation id) or when the rendered context is empty.
- */
-export function resolveWorkspaceTopLevelContext(
-  conversationId: string | undefined,
-): string | null {
-  const conversation = findConversationOrSubagent(conversationId);
-  if (!conversation) return null;
-  refreshWorkspaceTopLevelContextIfNeeded(conversation);
-  return conversation.workspaceTopLevelContext;
-}
-
 /** Refresh workspace top-level directory context if needed. */
 export function refreshWorkspaceTopLevelContextIfNeeded(
   ctx: WorkspaceConversationContext,

package/src/daemon/conversation.ts

@@ -128,6 +128,7 @@ import {
   createResolveToolsCallback,
   createToolExecutor,
 } from "./conversation-tool-setup.js";
+import { refreshWorkspaceTopLevelContextIfNeeded as refreshWorkspaceImpl } from "./conversation-workspace.js";
 import { canonicalizeTimeZone } from "./date-context.js";
 import { HostAppControlProxy } from "./host-app-control-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
@@ -1098,6 +1099,7 @@ export class Conversation {
     // etc.) — skip those so they don't silently reset the counter.
     if (result.summaryFailed !== undefined) {
       await this.agentLoop.compactionCircuit.recordOutcome(
+        this,
         result.summaryFailed,
         this.sendToClient,
       );
@@ -1344,6 +1346,10 @@ export class Conversation {
 
   // ── Workspace ────────────────────────────────────────────────────
 
+  refreshWorkspaceTopLevelContextIfNeeded(): void {
+    refreshWorkspaceImpl(this);
+  }
+
   markWorkspaceTopLevelDirty(): void {
     this.workspaceTopLevelDirty = true;
   }

package/src/daemon/external-plugins-bootstrap.ts

@@ -2,22 +2,21 @@
  * Plugin bootstrap — runs every registered plugin's `init()` hook once during
  * daemon startup.
  *
- * The registry is populated before this runs: first-party defaults are
- * registered explicitly (step 1 below), user plugins are registered by the
- * user-plugin loader from the workspace `plugins/` directory, and hot-reload
- * registers at runtime. By the time {@link bootstrapPlugins} runs, the
- * registry has been fully populated for this boot cycle. This function:
+ * Plugins register themselves via side-effect imports elsewhere in the boot
+ * sequence (first-party) or at runtime (hot-reload). By the time
+ * {@link bootstrapPlugins} runs, the registry has been fully populated for
+ * this boot cycle. This function:
  *
  * 1. Registers the canonical first-party default plugins via
- *    {@link registerDefaultPlugins}. Registration is idempotent so repeat
- *    calls (e.g. during integration tests) do not throw.
+ *    {@link registerDefaultPlugins} (one per pipeline). Registration is
+ *    idempotent so repeat calls (e.g. during integration tests) do not throw.
  * 2. Walks {@link getRegisteredPlugins} in registration order.
  * 3. For each plugin, consults `manifest.requiresFlag` against
  *    {@link isAssistantFeatureFlagEnabled}. If any listed flag is disabled,
  *    the plugin is skipped wholesale — no `init()`, no tool/route/skill
  *    contributions, no entry in the shutdown hook, and the plugin is also
- *    dropped from the registry via {@link unregisterPlugin} so none of its
- *    hooks participate in the turn lifecycle. This is the primary mechanism for
+ *    dropped from the registry via {@link unregisterPlugin} so its middleware
+ *    stops participating in pipeline runs. This is the primary mechanism for
  *    shipping experimental plugins behind a feature flag.
  * 4. Resolves the plugin's `manifest.requiresCredential` entries via the
  *    credential store helper ({@link getSecureKeyAsync}). In Docker mode
@@ -262,8 +261,9 @@ export async function bootstrapPlugins(): Promise<void> {
   // Tear down a plugin's contributions AND remove it from the registry. The
   // two steps always move together on the bootstrap failure path: the former
   // clears tools/routes/skills (so they stop appearing to the model/HTTP
-  // server), the latter drops the plugin's entry from the Map (so the registry
-  // doesn't expose an uninitialized plugin's hooks).
+  // server), the latter drops the plugin's entry from the Map (so
+  // `getMiddlewaresFor` doesn't re-enter an uninitialized plugin on the next
+  // pipeline invocation).
   // Shutdown context is identical for every plugin in this boot — construct
   // once and reuse across the bootstrap-failure rollback and the normal
   // shutdown hook below. Only `assistantVersion` is exposed today; future

package/src/daemon/handlers/conversations.ts

@@ -8,11 +8,9 @@ import { createAbortReason } from "../../util/abort-reasons.js";
 import { truncate } from "../../util/truncate.js";
 import { regenerate } from "../conversation-history.js";
 import {
+  clearAllActiveConversations,
   conversationEntries,
   findConversation,
-} from "../conversation-registry.js";
-import {
-  clearAllActiveConversations,
   getOrCreateConversation,
   touchConversation,
 } from "../conversation-store.js";

package/src/daemon/handlers/skills.ts

@@ -31,10 +31,7 @@ import {
   isTextMimeType as isTextMime,
   MAX_INLINE_TEXT_SIZE,
 } from "../../runtime/routes/workspace-utils.js";
-import {
-  getCachedCatalogSync,
-  getCatalog,
-} from "../../skills/catalog-cache.js";
+import { getCachedCatalogSync, getCatalog } from "../../skills/catalog-cache.js";
 import type { SkillFileEntry } from "../../skills/catalog-files.js";
 import {
   catalogSkillToSlim,

package/src/daemon/lifecycle.ts

@@ -98,7 +98,6 @@ import {
   updateWorkItem,
 } from "../work-items/work-item-store.js";
 import { WorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
-import { repairAdaptiveThinkingOnManagedProfiles } from "../workspace/migrations/097-enable-adaptive-thinking-managed-profiles.js";
 import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
 import { runWorkspaceMigrations } from "../workspace/migrations/runner.js";
 import {
@@ -590,26 +589,6 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
-    // Re-run the adaptive thinking repair after overlay merge + profile seeding.
-    // Workspace migration 097 enables adaptive thinking on managed profiles, but
-    // it runs before mergeDefaultWorkspaceConfig() which can overwrite the fix
-    // with overlay profiles that have thinking disabled or absent. On-platform
-    // instances where the overlay supplies "balanced" / "quality-optimized"
-    // profiles without thinking enabled would be stuck permanently because the
-    // migration is already checkpointed as completed. This idempotent repair
-    // ensures thinking is enabled regardless of overlay ordering.
-    if (defaultConfigMerge.hadOverlay) {
-      try {
-        repairAdaptiveThinkingOnManagedProfiles(getWorkspaceDir());
-        log.info("Post-overlay adaptive thinking repair complete");
-      } catch (err) {
-        log.warn(
-          { err },
-          "Post-overlay adaptive thinking repair failed — continuing startup",
-        );
-      }
-    }
-
     log.info("Daemon startup: loading config");
     const config = loadConfig();
 

package/src/daemon/server.ts

@@ -39,8 +39,6 @@ import {
   conversationEntries,
   deleteConversation,
   getConversationMap,
-} from "./conversation-registry.js";
-import {
   getOrCreateConversation as getOrCreateActiveConversation,
   initConversationLifecycle,
   setCesClientPromise,

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

@@ -85,7 +85,6 @@ const stubConfig: {
     activeHoursStart: number | null;
     activeHoursEnd: number | null;
     maxConsecutiveRuns: number | null;
-    maxDailyRuns: number | null;
     disposition: string;
   };
 } = {
@@ -95,7 +94,6 @@ const stubConfig: {
     activeHoursStart: null,
     activeHoursEnd: null,
     maxConsecutiveRuns: null,
-    maxDailyRuns: null,
     disposition: "Default disposition text.",
   },
 };
@@ -197,7 +195,6 @@ mock.module("../heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: () => 0,
   markStaleRunningAsError: () => 0,
   countCompletedHeartbeatRuns: () => 10,
-  countCompletedRunsToday: () => 0,
   countRecentConsecutiveRuns: () => 0,
 }));
 

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

@@ -24,8 +24,7 @@ export type HeartbeatSkipReason =
   | "outside_active_hours"
   | "overlap"
   | "pre_first_user_message"
-  | "max_consecutive_runs"
-  | "max_daily_runs";
+  | "max_consecutive_runs";
 
 export interface HeartbeatRunRecord {
   id: string;
@@ -218,27 +217,6 @@ export function countCompletedHeartbeatRuns(): number {
   return row?.count ?? 0;
 }
 
-/**
- * Count heartbeat runs that completed with status `ok` today (local midnight).
- */
-export function countCompletedRunsToday(): number {
-  const db = getDb();
-  const now = new Date();
-  const startOfDay = new Date(
-    now.getFullYear(),
-    now.getMonth(),
-    now.getDate(),
-  ).getTime();
-  const row = db
-    .select({ count: sql<number>`count(*)` })
-    .from(heartbeatRuns)
-    .where(
-      sql`${heartbeatRuns.status} = 'ok' AND ${heartbeatRuns.scheduledFor} >= ${startOfDay}`,
-    )
-    .get();
-  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