@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/daemon/conversation-agent-loop.ts

@@ -70,7 +70,6 @@ import type { UserPromptSubmitContext } from "../plugin-api/types.js";
 import { runHook } from "../plugins/pipeline.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
-import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { resolveCapabilities } from "../runtime/capabilities.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
@@ -190,8 +189,8 @@ export interface AssistantSurface {
 // ── abort watchdog ───────────────────────────────────────────────────
 
 /**
- * Generous backstop that drives an aborted turn to its `finally` even if some
- * awaited operation fails to observe the abort signal.
+ * Backstop that drives an aborted turn to its `finally` even if some awaited
+ * operation fails to observe the abort signal.
  *
  * Abort is otherwise cooperative and already wired into the slow paths: the
  * provider call forwards the signal to its HTTP/streaming fetch, and tool
@@ -199,10 +198,11 @@ export interface AssistantSurface {
  * watchdog only fires when a future code path silently ignores abort — without
  * it, such a path would hang the loop forever and latch the conversation's
  * `processing` flag true (the wedged "Thinking…" indicator). It is
- * defense-in-depth, not the primary mechanism, so the timeout is deliberately
- * generous; in the common case abort settles in-flight work well before it.
+ * defense-in-depth, not the primary mechanism: in the common case abort settles
+ * in-flight work in well under a second, so a few seconds is ample headroom for
+ * a cooperative unwind while still releasing a genuinely wedged turn promptly.
  */
-const ABORT_WATCHDOG_MS = 45_000;
+const ABORT_WATCHDOG_MS = 5_000;
 
 /**
  * Race `work` against an abort watchdog. The watchdog stays disarmed until the
@@ -350,18 +350,11 @@ export async function runAgentLoopImpl(
 
   const config = getConfig();
 
-  // Tool-based auto-routing: the switch_inference_profile tool lets the model
-  // self-select a different profile mid-turn. Reset the per-turn slot so a
-  // stale selection from a previous turn doesn't leak forward.
-  ctx.toolRoutedProfile = undefined;
-
   const turnOverrideProfile = userExplicitOverride;
   const forceOverrideProfile = options?.forceOverrideProfile === true;
 
   const readCurrentOverrideProfile = (): string | undefined =>
-    options?.overrideProfile ??
-    resolveOverrideProfile(ctx) ??
-    ctx.toolRoutedProfile;
+    options?.overrideProfile ?? resolveOverrideProfile(ctx);
 
   const effectiveContextWindow = resolveEffectiveContextWindow({
     llm: config.llm,
@@ -383,7 +376,6 @@ export async function runAgentLoopImpl(
   ctx.contextWindowManager.updateConfig(currentContextWindowConfig);
 
   let appliedOverrideProfile = turnOverrideProfile;
-  let emittedToolRoutedProfile: string | undefined;
   const refreshCurrentProfileState = (): string | undefined => {
     const currentOverrideProfile = readCurrentOverrideProfile();
     if (currentOverrideProfile !== appliedOverrideProfile) {
@@ -410,23 +402,6 @@ export async function runAgentLoopImpl(
       );
     }
 
-    // Emit turn_profile_auto_routed when the tool-based router selects a
-    // new profile. Deduplicated so the event fires at most once per profile.
-    if (
-      ctx.toolRoutedProfile &&
-      ctx.toolRoutedProfile !== emittedToolRoutedProfile
-    ) {
-      emittedToolRoutedProfile = ctx.toolRoutedProfile;
-      const profileEntry = config.llm.profiles?.[ctx.toolRoutedProfile];
-      const label = profileEntry?.label ?? ctx.toolRoutedProfile;
-      broadcastMessage({
-        type: "turn_profile_auto_routed",
-        conversationId: ctx.conversationId,
-        profile: ctx.toolRoutedProfile,
-        profileLabel: label,
-      });
-    }
-
     ctx.currentTurnOverrideProfile = currentOverrideProfile;
     return currentOverrideProfile;
   };
@@ -790,10 +765,7 @@ export async function runAgentLoopImpl(
     // the post-compaction hook re-emits this same value during in-loop recovery
     // instead of re-resolving against contact/member registry state that may
     // have drifted mid-turn.
-    const actorContext = resolveTurnInboundActorContext(
-      ctx.trustContext,
-      ctx.assistantId,
-    );
+    const actorContext = resolveTurnInboundActorContext(ctx.trustContext);
     ctx.currentTurnInboundActorContext = actorContext;
 
     // Surface long gaps between user messages so the model can acknowledge
@@ -980,6 +952,7 @@ export async function runAgentLoopImpl(
           compactInPlace,
           isNonInteractive,
           modelProfileKey,
+          ...(ctx.modelOverride ? { model: ctx.modelOverride } : {}),
         }),
         abortController.signal,
         watchdogMs,

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

@@ -13,6 +13,7 @@ import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { isMemoryV3Live } from "../config/memory-v3-gate.js";
 import type { LLMCallSite, LLMConfig } from "../config/schemas/llm.js";
+import { findContactInfoById } from "../contacts/contact-store.js";
 import {
   NOW_SCRATCHPAD_STRIP_PREFIXES,
   stripSpotlightInjections,
@@ -60,14 +61,8 @@ import type {
   TurnContext,
 } from "../plugins/types.js";
 import type { ContentBlock, Message } from "../providers/types.js";
-import {
-  type ActorTrustContext,
-  resolveActorTrust,
-  type TrustClass,
-} from "../runtime/actor-trust-resolver.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { resolveCapabilities } from "../runtime/capabilities.js";
-import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/acl-enforcement.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { SubagentState } from "../subagent/types.js";
 import { TERMINAL_STATUSES } from "../subagent/types.js";
@@ -156,32 +151,8 @@ export function inboundActorContextFromTrustContext(
     actorMemberDisplayName: ctx.requesterMemberDisplayName,
     trustClass: ctx.trustClass,
     guardianIdentity: ctx.guardianExternalUserId,
-  };
-}
-
-/**
- * Construct an InboundActorContext from an ActorTrustContext (the new
- * unified trust resolver output from M1).
- */
-export function inboundActorContextFromTrust(
-  ctx: ActorTrustContext,
-): InboundActorContext {
-  return {
-    sourceChannel: ctx.actorMetadata.channel,
-    canonicalActorIdentity: ctx.canonicalSenderId,
-    actorIdentifier: ctx.actorMetadata.identifier,
-    actorDisplayName: ctx.actorMetadata.displayName,
-    actorSenderDisplayName: ctx.actorMetadata.senderDisplayName,
-    actorMemberDisplayName: ctx.actorMetadata.memberDisplayName,
-    trustClass: ctx.trustClass,
-    guardianIdentity: ctx.guardianBindingMatch?.guardianExternalUserId,
-    memberStatus: ctx.memberRecord
-      ? channelStatusToMemberStatus(ctx.memberRecord.channel.status)
-      : undefined,
-    memberPolicy: ctx.memberRecord?.channel.policy ?? undefined,
-    contactNotes: ctx.memberRecord?.contact.notes ?? undefined,
-    contactInteractionCount:
-      ctx.memberRecord?.contact.interactionCount ?? undefined,
+    memberStatus: ctx.memberStatus,
+    memberPolicy: ctx.memberPolicy,
   };
 }
 
@@ -190,33 +161,30 @@ export function inboundActorContextFromTrust(
  * conversation's trust context, for the unified `<turn_context>` actor section.
  *
  * Returns `null` when there is no trust context and on guardian (owner) turns —
- * the actor section is suppressed for the owner. When the trust context carries
- * enough identity to look up member status / policy and the guardian binding,
- * the unified actor-trust resolver is preferred; otherwise the context is
- * projected directly. Derives purely from the passed trust context, so callers
+ * the actor section is suppressed for the owner. ACL fields (trust class,
+ * member status/policy, guardian binding) come from the verdict-derived trust
+ * context; INFO fields (contact notes, interaction count) are joined locally by
+ * contact ID. Derives purely from the passed trust context, so callers
  * self-resolve it from the live conversation rather than threading it.
  */
 export function resolveTurnInboundActorContext(
   trustContext: TrustContext | undefined,
-  assistantId: string | undefined,
 ): InboundActorContext | null {
   if (!trustContext) {
     return null;
   }
-  let resolved: InboundActorContext;
-  if (trustContext.requesterExternalUserId && trustContext.requesterChatId) {
-    const actorTrust = resolveActorTrust({
-      assistantId: assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
-      sourceChannel: trustContext.sourceChannel,
-      conversationExternalId: trustContext.requesterChatId,
-      actorExternalId: trustContext.requesterExternalUserId,
-      actorDisplayName: trustContext.requesterSenderDisplayName,
-    });
-    resolved = inboundActorContextFromTrust(actorTrust);
-  } else {
-    resolved = inboundActorContextFromTrustContext(trustContext);
+  const resolved = inboundActorContextFromTrustContext(trustContext);
+  if (resolved.trustClass === "guardian") {
+    return null;
   }
-  return resolved.trustClass === "guardian" ? null : resolved;
+  if (trustContext.requesterContactId) {
+    const info = findContactInfoById(trustContext.requesterContactId);
+    if (info) {
+      resolved.contactNotes = info.notes ?? undefined;
+      resolved.contactInteractionCount = info.interactionCount;
+    }
+  }
+  return resolved;
 }
 
 /**
@@ -681,13 +649,14 @@ export function stripNowScratchpad(messages: Message[]): Message[] {
 }
 
 /**
- * Prepend channel capability context to the last user message so the
- * model knows what the current channel can and cannot do.
+ * Build the `<channel_capabilities>` block text for the given capabilities, or
+ * `null` on the happy path (desktop, full capabilities, no special context)
+ * where no block is injected. Split from {@link injectChannelCapabilityContext}
+ * so callers can capture the exact injected text for metadata persistence.
  */
-export function injectChannelCapabilityContext(
-  message: Message,
+export function buildChannelCapabilityBlock(
   caps: ChannelCapabilities,
-): Message {
+): string | null {
   // Happy path: desktop with full capabilities and no special context — skip injection.
   if (
     caps.dashboardCapable &&
@@ -696,7 +665,7 @@ export function injectChannelCapabilityContext(
     !isGroupChatType(caps.chatType) &&
     caps.clientOS !== "macos"
   ) {
-    return message;
+    return null;
   }
 
   const lines: string[] = ["<channel_capabilities>"];
@@ -769,7 +738,16 @@ export function injectChannelCapabilityContext(
 
   lines.push("</channel_capabilities>");
 
-  const block = lines.join("\n");
+  return lines.join("\n");
+}
+
+/** Prepend the `<channel_capabilities>` block (if any) to a user message. */
+export function injectChannelCapabilityContext(
+  message: Message,
+  caps: ChannelCapabilities,
+): Message {
+  const block = buildChannelCapabilityBlock(caps);
+  if (block === null) return message;
   return {
     ...message,
     content: [{ type: "text", text: block }, ...message.content],
@@ -1512,6 +1490,14 @@ export function loadSlackActiveThreadFocusBlock(
  */
 export type InjectionMode = "full" | "minimal";
 
+/**
+ * The `<non_interactive_context>` block appended on non-interactive turns.
+ * Module-scoped so `applyRuntimeInjections` both injects it and captures the
+ * exact text for metadata persistence from a single source of truth.
+ */
+export const NON_INTERACTIVE_CONTEXT_BLOCK =
+  "<non_interactive_context>\nNon-interactive scheduled task — do not ask for clarification or confirmation. Follow the instructions exactly using your best judgment. If recalled memory contains conflicting notes, prefer the explicit instruction in this message.\n</non_interactive_context>";
+
 /**
  * Per-turn injection bytes captured so `loadFromDb` can rehydrate historical
  * user messages byte-for-byte after a daemon restart or conversation
@@ -1527,6 +1513,27 @@ export interface RuntimeInjectionBlocks {
   nowScratchpadBlock?: string;
   pkbContextBlock?: string;
   memoryV2StaticBlock?: string;
+  /**
+   * The `<background_turn>` block the `background-turn` default injector
+   * attached this turn (background/scheduled non-interactive turns only).
+   * Persisted under `metadata.backgroundTurnBlock` so `loadFromDb` rehydrates
+   * it byte-for-byte on reload/fork — without it, a fork of a background
+   * source (memory retrospective) drops the block and breaks message-tier
+   * prefix-cache parity with the source's live turns.
+   */
+  backgroundTurnBlock?: string;
+  /**
+   * The `<channel_capabilities>` block injected this turn (non-default channel
+   * capabilities). Persisted under `metadata.channelCapabilitiesBlock` for the
+   * same reload/fork cache-parity reason as {@link backgroundTurnBlock}.
+   */
+  channelCapabilitiesBlock?: string;
+  /**
+   * The `<non_interactive_context>` block injected this turn (non-interactive
+   * turns only). Persisted under `metadata.nonInteractiveContextBlock` for the
+   * same reload/fork cache-parity reason as {@link backgroundTurnBlock}.
+   */
+  nonInteractiveContextBlock?: string;
   /**
    * UNWRAPPED inner text of the memory-v3 frozen net-new card block the v3
    * injector attached this turn, mirroring v2's unwrapped `memoryInjectedBlock`
@@ -2108,6 +2115,9 @@ export async function applyRuntimeInjections(
   let pkbSystemReminderCaptured: string | undefined;
   let memoryV2StaticCaptured: string | undefined;
   let memoryV3Captured: string | undefined;
+  let backgroundTurnCaptured: string | undefined;
+  let channelCapabilitiesCaptured: string | undefined;
+  let nonInteractiveContextCaptured: string | undefined;
   const initialTail = runMessages[runMessages.length - 1];
   const initialTailIsUser = !!initialTail && initialTail.role === "user";
   if (initialTailIsUser) {
@@ -2131,6 +2141,9 @@ export async function applyRuntimeInjections(
         case "memory-v2-static":
           memoryV2StaticCaptured = block.text;
           break;
+        case "background-turn":
+          backgroundTurnCaptured = block.text;
+          break;
         case MEMORY_V3_BLOCK_ID: {
           // The v3 frozen card block is persisted UNWRAPPED (the v2
           // `memoryInjectedBlock` contract — rehydration re-wraps on use).
@@ -2260,16 +2273,14 @@ export async function applyRuntimeInjections(
   if (isNonInteractive) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
+      nonInteractiveContextCaptured = NON_INTERACTIVE_CONTEXT_BLOCK;
       result = [
         ...result.slice(0, -1),
         {
           ...userTail,
           content: [
             ...userTail.content,
-            {
-              type: "text" as const,
-              text: "<non_interactive_context>\nNon-interactive scheduled task — do not ask for clarification or confirmation. Follow the instructions exactly using your best judgment. If recalled memory contains conflicting notes, prefer the explicit instruction in this message.\n</non_interactive_context>",
-            },
+            { type: "text" as const, text: NON_INTERACTIVE_CONTEXT_BLOCK },
           ],
         },
       ];
@@ -2310,10 +2321,21 @@ export async function applyRuntimeInjections(
   if (channelCapabilities) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectChannelCapabilityContext(userTail, channelCapabilities),
-      ];
+      const channelCapabilityBlock =
+        buildChannelCapabilityBlock(channelCapabilities);
+      if (channelCapabilityBlock !== null) {
+        channelCapabilitiesCaptured = channelCapabilityBlock;
+        result = [
+          ...result.slice(0, -1),
+          {
+            ...userTail,
+            content: [
+              { type: "text" as const, text: channelCapabilityBlock },
+              ...userTail.content,
+            ],
+          },
+        ];
+      }
     }
   }
 
@@ -2372,6 +2394,9 @@ export async function applyRuntimeInjections(
       pkbContextBlock: pkbContextCaptured,
       memoryV2StaticBlock: memoryV2StaticCaptured,
       memoryV3InjectedBlock: memoryV3Captured,
+      backgroundTurnBlock: backgroundTurnCaptured,
+      channelCapabilitiesBlock: channelCapabilitiesCaptured,
+      nonInteractiveContextBlock: nonInteractiveContextCaptured,
       memoryV3Active,
       injectorChainBlock,
     },

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

@@ -17,6 +17,7 @@ import type { LLMCallSite } from "../config/schemas/llm.js";
 import { getBindingByConversation } from "../memory/external-conversation-store.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import { advisorEnabledForProfile } from "../plugins/defaults/advisor/advisor-gate.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
@@ -60,12 +61,6 @@ import { FALLBACK_TURN_TRUST, resolveTrustClass } from "./trust-context.js";
 
 const log = getLogger("conversation-tool-setup");
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
-import { AUTO_PROFILE_KEY } from "../config/seed-inference-profiles.js";
-import {
-  buildSwitchInferenceProfileToolDef,
-  SWITCH_INFERENCE_PROFILE_TOOL_NAME,
-} from "./switch-inference-profile-tool.js";
 import type {
   SubagentToolGateMode,
   ToolSetupContext,
@@ -92,8 +87,10 @@ export type {
  * agent's). The conversation id is threaded as the mix selection seed so
  * mix-profile arms match what the dispatch path actually ran.
  *
- * Returns `null` on any failure: attribution is telemetry-only and must
- * never break tool execution (or skill loads, which reuse this helper).
+ * Returns `null` on any failure: attribution must never break tool execution
+ * (or skill loads, which reuse this helper). Consumers read it best-effort —
+ * usage telemetry, and `subagent_spawn`, which inherits the resolved
+ * `appliedProfile` so a child defaults to the invoking turn's profile.
  */
 export function resolveConversationAttribution(
   ctx: Pick<
@@ -168,11 +165,11 @@ export function createToolExecutor(
       resolveToolInvocationAlias(name, input, ctx.allowedToolNames);
 
     // The execution-layer gate must run FIRST — before any interception or
-    // pre-execution side effect (switch_inference_profile profile switching,
-    // DoorDash step marking) — so a non-allowlisted tool can neither run nor
-    // mutate conversation state. `skill_execute` is dispatch indirection: it
-    // is gated on its resolved inner tool name inside the interception below,
-    // mirroring how wire mode gates the underlying tool, not the wrapper.
+    // pre-execution side effect (DoorDash step marking) — so a non-allowlisted
+    // tool can neither run nor mutate conversation state. `skill_execute` is
+    // dispatch indirection: it is gated on its resolved inner tool name inside
+    // the interception below, mirroring how wire mode gates the underlying
+    // tool, not the wrapper.
     if (executionName !== "skill_execute") {
       const rejection = rejectNonAllowlistedTool(executionName);
       if (rejection) return rejection;
@@ -269,36 +266,6 @@ export function createToolExecutor(
       },
     };
 
-    // Intercept switch_inference_profile: daemon-internal tool that lets the
-    // model self-select a different inference profile mid-turn. No permission
-    // checks — this is a control-flow signal, not a user-visible tool.
-    if (executionName === SWITCH_INFERENCE_PROFILE_TOOL_NAME) {
-      const profile =
-        typeof executionInput.profile === "string"
-          ? executionInput.profile
-          : "";
-      const config = getConfig();
-      const profileEntry = config.llm.profiles?.[profile];
-      if (!profileEntry) {
-        return {
-          content: `Profile "${profile}" not found. Available profiles: ${Object.keys(config.llm.profiles ?? {}).join(", ")}`,
-          isError: true,
-        };
-      }
-      if (profileEntry.status === "disabled") {
-        return {
-          content: `Profile "${profile}" is disabled.`,
-          isError: true,
-        };
-      }
-      ctx.toolRoutedProfile = profile;
-      const label = profileEntry.label ?? profile;
-      return {
-        content: `Switched to ${label} profile. Continue with your response.`,
-        isError: false,
-      };
-    }
-
     // Intercept skill_execute: extract the real tool name and input, then
     // route through the full executor pipeline so the underlying tool's
     // risk level, permission checks, hooks, and lifecycle events all fire
@@ -447,7 +414,7 @@ export interface SkillProjectionContext {
    * host tools into the LLM tool definitions.
    */
   readonly transportInterface?: InterfaceId;
-  /** Per-turn override profile, read by the switch_inference_profile tool injection. */
+  /** Per-turn override profile. */
   currentTurnOverrideProfile?: string;
   /**
    * Conversation id for `skill_loaded` telemetry. Absent (e.g. minimal test
@@ -597,6 +564,15 @@ export function isToolActiveForContext(
       return true;
     }
   }
+  if (name === "advisor") {
+    // Gated per chat-profile (`ProfileEntry.advisorEnabled`): when the resolved
+    // profile disables the advisor, omit the tool from the wire list so the
+    // model never sees a tool it can only no-op on. Resolves the profile the
+    // same way the advisor's execution-time guard does (the per-turn override,
+    // else the active profile). The wire list is fixed before PRE_MODEL_CALL
+    // hooks run, so later profile changes from hooks are not reflected here.
+    return advisorEnabledForProfile(ctx.currentTurnOverrideProfile ?? null);
+  }
   if (UI_SURFACE_TOOL_NAMES.has(name)) {
     if (
       channelCapabilities?.channel === "slack" &&
@@ -799,25 +775,6 @@ export function createResolveToolsCallback(
     ctx.allowedToolNames = turnAllowed;
     const baseDefs = injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET);
 
-    const config = getConfig();
-    if (
-      isAssistantFeatureFlagEnabled("query-complexity-routing", config) &&
-      config.llm
-    ) {
-      const effectiveProfile =
-        ctx.currentTurnOverrideProfile ?? config.llm.activeProfile;
-      if (effectiveProfile === AUTO_PROFILE_KEY) {
-        const toolDef = buildSwitchInferenceProfileToolDef(
-          config.llm.profiles ?? {},
-          effectiveProfile,
-        );
-        if (toolDef) {
-          turnAllowed.add(SWITCH_INFERENCE_PROFILE_TOOL_NAME);
-          return [...baseDefs, toolDef];
-        }
-      }
-    }
-
     return baseDefs;
   };
 }