@vellumai/assistant 0.6.5 → 0.7.0

package/src/daemon/conversation.ts

@@ -5,7 +5,7 @@
  * - conversation-lifecycle.ts    — loadFromDb, abort, dispose
  * - conversation-messaging.ts    — enqueueMessage, persistUserMessage, redirectToSecurePrompt
  * - conversation-agent-loop.ts   — runAgentLoop, generateTitle
- * - conversation-notifiers.ts    — watch/call notifier registration
+ * - conversation-notifiers.ts    — call notifier registration
  * - conversation-tool-setup.ts   — tool definitions, executor, resolveTools callback
  * - conversation-media-retry.ts  — media trimming + raceWithTimeout
  * - conversation-process.ts      — drainQueue, processMessage
@@ -43,39 +43,27 @@ import {
   ToolProfiler,
 } from "../events/tool-profiling-listener.js";
 import { registerToolTraceListener } from "../events/tool-trace-listener.js";
-import { getHookManager } from "../hooks/manager.js";
-import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
-import {
-  getConversationOriginChannel,
-  updateConversationContextWindow,
-  updateConversationHostAccess,
-} from "../memory/conversation-crud.js";
+import { getConversationOriginChannel } from "../memory/conversation-crud.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
-import { patternMatchesCandidate } from "../permissions/trust-store.js";
 import type { UserDecision } from "../permissions/types.js";
-import {
-  isConversationHostAccessDecision,
-  isConversationHostAccessEnabled,
-  isConversationHostAccessEnablePrompt,
-} from "../permissions/v2-consent-policy.js";
 import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import type { Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import type { AuthContext } from "../runtime/auth/types.js";
-import * as approvalOverrides from "../runtime/conversation-approval-overrides.js";
 import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
-import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { ToolExecutor } from "../tools/executor.js";
+import type { ToolLifecycleEvent } from "../tools/types.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import type { AbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import type { AssistantAttachmentDraft } from "./assistant-attachments.js";
 import {
+  applyCompactionResult,
   runAgentLoopImpl,
   trackCompactionOutcome,
 } from "./conversation-agent-loop.js";
@@ -104,10 +92,7 @@ import {
 } from "./conversation-process.js";
 import type { QueueDrainReason } from "./conversation-queue-manager.js";
 import { MessageQueue } from "./conversation-queue-manager.js";
-import type {
-  ChannelCapabilities,
-  TrustContext,
-} from "./conversation-runtime-assembly.js";
+import type { ChannelCapabilities } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
   createSurfaceMutex,
@@ -127,6 +112,7 @@ import { HostBrowserProxy } from "./host-browser-proxy.js";
 import type { CuObservationResult } from "./host-cu-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
 import { HostFileProxy } from "./host-file-proxy.js";
+import { HostTransferProxy } from "./host-transfer-proxy.js";
 import type {
   ServerMessage,
   SurfaceData,
@@ -147,14 +133,12 @@ const log = getLogger("conversation");
 export interface ConversationMemoryPolicy {
   scopeId: string;
   includeDefaultFallback: boolean;
-  strictSideEffects: boolean;
 }
 
 export const DEFAULT_MEMORY_POLICY: Readonly<ConversationMemoryPolicy> =
   Object.freeze({
     scopeId: "default",
     includeDefaultFallback: false,
-    strictSideEffects: false,
   });
 
 export { findLastUndoableUserMessageIndex } from "./conversation-history.js";
@@ -162,6 +146,7 @@ export type {
   QueueDrainReason,
   QueuePolicy,
 } from "./conversation-queue-manager.js";
+import type { TrustContext } from "./trust-context.js";
 
 export class Conversation {
   public readonly conversationId: string;
@@ -217,6 +202,7 @@ export class Conversation {
   /** @internal */ hostBrowserProxy?: HostBrowserProxy;
   /** @internal */ hostCuProxy?: HostCuProxy;
   /** @internal */ hostFileProxy?: HostFileProxy;
+  /** @internal */ hostTransferProxy?: HostTransferProxy;
   /**
    * Optional override sender used by `restoreBrowserProxyAvailability` so
    * registry-routed transports can preserve their sender across drain queue
@@ -244,6 +230,7 @@ export class Conversation {
    */
   /** @internal */ currentTurnTrustContext?: TrustContext;
   /** @internal */ currentTurnChannelCapabilities?: ChannelCapabilities;
+  /** @internal */ currentTurnOverrideProfile?: string;
   /** @internal */ authContext?: AuthContext;
   /** @internal */ loadedHistoryTrustClass?: TrustClass;
   /** @internal */ voiceCallControlPrompt?: string;
@@ -365,6 +352,7 @@ export class Conversation {
     toolName?: string,
     toolUseId?: string,
   ) => void;
+  private cacheWarmAbort?: AbortController;
 
   constructor(
     conversationId: string,
@@ -430,7 +418,7 @@ export class Conversation {
       broadcastToAllClients,
     );
 
-    // Register watch/call notifiers (reads ctx properties lazily)
+    // Register call notifiers (reads ctx properties lazily)
     registerConversationNotifiers(conversationId, this);
 
     // Tool infrastructure
@@ -447,9 +435,7 @@ export class Conversation {
     const publishToolDomainEvent = createToolDomainEventPublisher(
       this.eventBus,
     );
-    const handleToolLifecycleEvent = (
-      event: import("../tools/types.js").ToolLifecycleEvent,
-    ) => {
+    const handleToolLifecycleEvent = (event: ToolLifecycleEvent) => {
       auditToolLifecycleEvent(event);
       return publishToolDomainEvent(event);
     };
@@ -489,7 +475,7 @@ export class Conversation {
     const resolvedModel: string | undefined = modelOverride;
 
     const resolveSystemPromptCallback = (
-      _history: import("../providers/types.js").Message[],
+      _history: Message[],
     ): ResolvedSystemPrompt => {
       const resolved: ResolvedSystemPrompt = {
         systemPrompt: this.hasSystemPromptOverride
@@ -543,11 +529,6 @@ export class Conversation {
       config: llmDefault.contextWindow,
       toolTokenBudget: this.agentLoop.getToolTokenBudget(),
     });
-
-    void getHookManager().trigger("conversation-start", {
-      conversationId: this.conversationId,
-      workingDir: this.workingDir,
-    });
   }
 
   // ── Onboarding context ───────────────────────────────────────────
@@ -560,6 +541,61 @@ export class Conversation {
     return this.onboardingContext;
   }
 
+  // ── Prompt Cache Warming ─────────────────────────────────────────
+
+  /**
+   * Fire-and-forget LLM call with max_tokens=1 to populate the provider's
+   * prompt cache (system prompt + tools). Called after the canned first
+   * greeting so the user's next real message gets a cache hit.
+   */
+  warmPromptCache(): void {
+    this.cacheWarmAbort?.abort();
+    const abort = new AbortController();
+    this.cacheWarmAbort = abort;
+
+    const systemPrompt = this.hasSystemPromptOverride
+      ? this.systemPrompt
+      : (() => {
+          const persona = resolvePersonaContext(
+            this.currentTurnTrustContext,
+            this.currentTurnChannelCapabilities,
+          );
+          return buildSystemPrompt({
+            hasNoClient: this.hasNoClient,
+            userPersona: persona.userPersona,
+            channelPersona: persona.channelPersona,
+            userSlug: persona.userSlug,
+            onboardingContext: this.getOnboardingContext(),
+          });
+        })();
+    const tools = buildToolDefinitions();
+    const provider = this.provider;
+
+    const warmMessage: Message = {
+      role: "user",
+      content: [{ type: "text", text: "hi" }],
+    };
+
+    provider
+      .sendMessage([warmMessage], tools, systemPrompt, {
+        config: { max_tokens: 1, callSite: "mainAgent" },
+        signal: abort.signal,
+      })
+      .then(() => {
+        log.info("Prompt cache warmed successfully");
+      })
+      .catch((err) => {
+        if (!abort.signal.aborted) {
+          log.warn({ err }, "Prompt cache warming failed (non-fatal)");
+        }
+      })
+      .finally(() => {
+        if (this.cacheWarmAbort === abort) {
+          this.cacheWarmAbort = undefined;
+        }
+      });
+  }
+
   // ── Lifecycle ────────────────────────────────────────────────────
 
   async loadFromDb(): Promise<void> {
@@ -624,6 +660,7 @@ export class Conversation {
       this.hostBrowserProxy?.updateSender(sendToClient, !hasNoClient);
       this.hostCuProxy?.updateSender(sendToClient, !hasNoClient);
       this.hostFileProxy?.updateSender(sendToClient, !hasNoClient);
+      this.hostTransferProxy?.updateSender(sendToClient, !hasNoClient);
     }
 
     // Replay last activity state so a reconnecting client sees the current phase
@@ -651,6 +688,7 @@ export class Conversation {
     this.hostBrowserProxy?.updateSender(this.sendToClient, false);
     this.hostCuProxy?.updateSender(this.sendToClient, false);
     this.hostFileProxy?.updateSender(this.sendToClient, false);
+    this.hostTransferProxy?.updateSender(this.sendToClient, false);
   }
 
   /**
@@ -667,17 +705,21 @@ export class Conversation {
       }
       this.hostCuProxy?.updateSender(this.sendToClient, true);
       this.hostFileProxy?.updateSender(this.sendToClient, true);
+      this.hostTransferProxy?.updateSender(this.sendToClient, true);
     }
   }
 
   /**
-   * Restore host browser proxy availability only. Used for interfaces that
-   * support host_browser but not the full desktop proxy set, so calling
-   * restoreProxyAvailability() would incorrectly re-enable bash/file/CU
-   * proxies that should stay disabled. Applicable to chrome-extension turns
-   * (which only support host_browser) and macOS turns with an active
-   * extension connection (which route browser tools through the extension
-   * registry instead of cdp-inspect/local).
+   * Restore host browser proxy availability only. Used in two scenarios:
+   *
+   * 1. **Chrome-extension turns** — only support host_browser (not the full
+   *    desktop proxy set), so calling restoreProxyAvailability() would
+   *    incorrectly re-enable bash/file/CU proxies.
+   * 2. **macOS turns** — when called from queue-drain, the browser proxy
+   *    sender needs to be either the registry-routed sender (when an
+   *    extension connection is present) or the SSE hub sender (when no
+   *    extension is connected). This helper resolves the correct sender
+   *    via `hostBrowserSenderOverride ?? sendToClient`.
    *
    * Unlike `restoreProxyAvailability()`, this helper does NOT gate on
    * `hasNoClient`. The chrome-extension interface is non-interactive (so
@@ -693,7 +735,9 @@ export class Conversation {
    * WebSocket rather than the SSE hub: if the queue-drain path called this
    * helper with `sendToClient`, the registry-routed sender established at
    * turn-start would be clobbered by the SSE hub emitter and
-   * host_browser_request frames would stop reaching the extension.
+   * host_browser_request frames would stop reaching the extension. When
+   * no override is set (macOS without extension), `sendToClient` is used
+   * so frames reach the desktop client via SSE.
    *
    * Callers must only invoke this when they know the current interface
    * supports host_browser (see `supportsHostProxy(id, "host_browser")`)
@@ -763,7 +807,6 @@ export class Conversation {
   }
 
   dispose(): void {
-    approvalOverrides.clearMode(this.conversationId);
     // Cancel all pending standalone surfaces so callers get a clean
     // cancellation instead of hanging forever. Emit dismiss notifications
     // to the client so surfaces don't remain visually active if the client
@@ -797,6 +840,7 @@ export class Conversation {
     this.hostBrowserProxy?.dispose();
     this.hostCuProxy?.dispose();
     this.hostFileProxy?.dispose();
+    this.hostTransferProxy?.dispose();
     // CES client is owned by DaemonServer — just drop the reference.
     // Do NOT close it here; the server manages the CES lifecycle.
     this.cesClient = undefined;
@@ -899,28 +943,7 @@ export class Conversation {
       return;
     }
 
-    const hostAccessEnablePrompt =
-      this.prompter.isHostAccessEnablePrompt(requestId) ||
-      isConversationHostAccessEnablePrompt(
-        pendingInteractions.get(requestId)?.confirmationDetails,
-      );
-    const effectiveDecision =
-      hostAccessEnablePrompt && !isConversationHostAccessDecision(decision)
-        ? "deny"
-        : decision;
-
-    if (
-      hostAccessEnablePrompt &&
-      effectiveDecision === "allow" &&
-      !isConversationHostAccessEnabled(this.conversationId)
-    ) {
-      updateConversationHostAccess(this.conversationId, true);
-      this.sendToClient({
-        type: "conversation_host_access_updated",
-        conversationId: this.conversationId,
-        hostAccess: true,
-      });
-    }
+    const effectiveDecision = decision;
 
     // Capture toolUseId before resolving (resolution deletes the pending entry)
     const toolUseId = this.prompter.getToolUseId(requestId);
@@ -933,15 +956,11 @@ export class Conversation {
       decisionContext,
     );
 
-    // Mode activation (setTimedMode / setConversationMode) is intentionally NOT
-    // done here. It is handled in permission-checker.ts where the
-    // guardian trust-class and conversation context are available.
-
     // Emit authoritative confirmation state and activity transition centrally
     // so ALL callers (HTTP handlers, /v1/confirm, channel bridges) get
     // consistent events without duplicating emission logic.
     const resolvedState =
-      effectiveDecision === "deny" || effectiveDecision === "always_deny"
+      effectiveDecision === "deny"
         ? ("denied" as const)
         : ("approved" as const);
     this.emitConfirmationStateChanged({
@@ -984,138 +1003,6 @@ export class Conversation {
       // Canonical request tracking should not break the primary approval flow.
     }
 
-    // Cascade to other pending confirmations that match this decision
-    this.cascadePendingApprovals(
-      requestId,
-      effectiveDecision,
-      selectedPattern,
-      hostAccessEnablePrompt,
-    );
-  }
-
-  /**
-   * After resolving one confirmation, auto-resolve other pending
-   * confirmations in the same conversation that match the decision.
-   *
-   * - allow_10m / allow_conversation → approve ALL pending in conversation
-   * - always_allow → approve pattern-matching pending
-   * - always_deny → deny pattern-matching pending
-   * - allow / deny (one-time) → no cascading
-   */
-  private cascadePendingApprovals(
-    primaryRequestId: string,
-    decision: UserDecision,
-    selectedPattern?: string,
-    hostAccessEnablePrompt = false,
-  ): void {
-    // Single-action decisions don't cascade
-    if (decision === "allow" || decision === "deny") {
-      if (!hostAccessEnablePrompt || decision !== "allow") {
-        return;
-      }
-    }
-
-    const pendingRequestIds = this.prompter.getPendingRequestIds();
-    if (pendingRequestIds.length === 0) return;
-
-    for (const candidateId of pendingRequestIds) {
-      if (candidateId === primaryRequestId) continue;
-
-      const interaction = pendingInteractions.get(candidateId);
-      if (!interaction) continue;
-      if (interaction.conversationId !== this.conversationId) continue;
-      if (interaction.kind !== "confirmation") continue;
-
-      if (
-        hostAccessEnablePrompt &&
-        (this.prompter.isHostAccessEnablePrompt(candidateId) ||
-          isConversationHostAccessEnablePrompt(interaction.confirmationDetails))
-      ) {
-        // Enabling computer access is conversation-scoped, so sibling host
-        // prompts should resolve immediately once the first approval lands.
-        pendingInteractions.resolve(candidateId);
-        this.handleConfirmationResponse(
-          candidateId,
-          "allow",
-          undefined,
-          undefined,
-          undefined,
-          {
-            source: "system",
-            causedByRequestId: primaryRequestId,
-          },
-        );
-        continue;
-      }
-
-      const cascadeResult = this.shouldCascade(
-        decision,
-        selectedPattern,
-        interaction.confirmationDetails,
-      );
-      if (!cascadeResult) continue;
-
-      // Consume from pending-interactions tracker
-      pendingInteractions.resolve(candidateId);
-
-      // Resolve via handleConfirmationResponse which emits events and
-      // syncs canonical status. Use simple "allow"/"deny" so the
-      // permission-checker won't save duplicate rules or re-activate
-      // temporary modes. Recursion terminates because allow/deny exit
-      // cascadePendingApprovals early.
-      this.handleConfirmationResponse(
-        candidateId,
-        cascadeResult.allow ? "allow" : "deny",
-        undefined,
-        undefined,
-        undefined,
-        {
-          source: "system",
-          causedByRequestId: primaryRequestId,
-        },
-      );
-    }
-  }
-
-  /**
-   * Determine whether a pending confirmation should be auto-resolved
-   * based on the cascading decision and pattern.
-   */
-  private shouldCascade(
-    decision: UserDecision,
-    selectedPattern: string | undefined,
-    details?: import("../runtime/pending-interactions.js").ConfirmationDetails,
-  ): { allow: boolean } | null {
-    // Temporary overrides apply to the entire conversation
-    if (decision === "allow_10m" || decision === "allow_conversation") {
-      return { allow: true };
-    }
-
-    // Persistent allow: cascade if the pattern matches any allowlist candidate.
-    // "always_allow" must NOT cascade to high-risk pending confirmations.
-    if (decision === "always_allow" && selectedPattern && details) {
-      if (details.riskLevel === "high") {
-        return null;
-      }
-      for (const option of details.allowlistOptions) {
-        if (patternMatchesCandidate(selectedPattern, option.pattern)) {
-          return { allow: true };
-        }
-      }
-      return null;
-    }
-
-    // Persistent deny: cascade denial if the pattern matches
-    if (decision === "always_deny" && selectedPattern && details) {
-      for (const option of details.allowlistOptions) {
-        if (patternMatchesCandidate(selectedPattern, option.pattern)) {
-          return { allow: false };
-        }
-      }
-      return null;
-    }
-
-    return null;
   }
 
   handleSecretResponse(
@@ -1173,6 +1060,28 @@ export class Conversation {
     this.hostFileProxy = proxy;
   }
 
+  resolveHostTransfer(
+    requestId: string,
+    result: {
+      isError: boolean;
+      bytesWritten?: number;
+      errorMessage?: string;
+    },
+  ): void {
+    this.hostTransferProxy?.resolveTransferResult(requestId, result);
+  }
+
+  setHostTransferProxy(proxy: HostTransferProxy | undefined): void {
+    if (this.hostTransferProxy && this.hostTransferProxy !== proxy) {
+      this.hostTransferProxy.dispose();
+    }
+    this.hostTransferProxy = proxy;
+  }
+
+  getHostTransferProxy(): HostTransferProxy | undefined {
+    return this.hostTransferProxy;
+  }
+
   resolveHostCu(requestId: string, observation: CuObservationResult): void {
     this.hostCuProxy?.resolve(requestId, observation);
   }
@@ -1249,24 +1158,14 @@ export class Conversation {
     // is `undefined` on early-return paths (no eligible messages, disabled,
     // etc.) — skip those so they don't silently reset the counter.
     if (result.summaryFailed !== undefined) {
-      trackCompactionOutcome(this, result.summaryFailed, this.sendToClient);
+      await trackCompactionOutcome(
+        this,
+        result.summaryFailed,
+        this.sendToClient,
+      );
     }
     if (result.compacted) {
-      this.messages = result.messages;
-      this.contextCompactedMessageCount += result.compactedPersistedMessages;
-      this.contextCompactedAt = Date.now();
-      updateConversationContextWindow(
-        this.conversationId,
-        result.summaryText,
-        this.contextCompactedMessageCount,
-      );
-      // Fire auto-analysis on compaction so the reflective agent can
-      // crystallize anything worth remembering before the context window
-      // narrows further.
-      enqueueAutoAnalysisOnCompaction(
-        this.conversationId,
-        this.trustContext?.trustClass,
-      );
+      applyCompactionResult(this, result, this.sendToClient, null);
     }
     return result;
   }
@@ -1416,11 +1315,19 @@ export class Conversation {
     userMessageId: string,
     onEvent: (msg: ServerMessage) => void,
     options?: {
-      skipPreMessageRollback?: boolean;
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
       callSite?: LLMCallSite;
+      /**
+       * Optional ad-hoc inference-profile override applied to every LLM call
+       * the loop issues for this turn. Forwarded into
+       * {@link runAgentLoopImpl} and threaded through to
+       * {@link AgentLoop.run} so each provider call carries
+       * `config.overrideProfile`. Subagents spawned during the turn inherit
+       * this value via {@link SubagentManager.spawn}.
+       */
+      overrideProfile?: string;
     },
   ): Promise<void> {
     return runAgentLoopImpl(this, content, userMessageId, onEvent, options);
@@ -1440,6 +1347,8 @@ export class Conversation {
     options?: { isInteractive?: boolean; callSite?: LLMCallSite },
     displayContent?: string,
   ): Promise<string> {
+    this.cacheWarmAbort?.abort();
+    this.cacheWarmAbort = undefined;
     return processMessageImpl(
       this as ProcessConversationContext,
       content,

package/src/daemon/daemon-control.ts

@@ -138,7 +138,7 @@ function isVellumDaemonProcess(pid: number): boolean {
  *  Wildcard addresses (0.0.0.0, ::) bind all interfaces but aren't
  *  connectable on all platforms — substitute loopback. IPv6 literals
  *  need brackets in URLs. */
-export function healthCheckHost(host: string): string {
+function healthCheckHost(host: string): string {
   if (host === "0.0.0.0") return "127.0.0.1";
   if (host === "::") return "[::1]";
   if (host.includes(":")) return `[${host}]`;
@@ -148,7 +148,7 @@ export function healthCheckHost(host: string): string {
 /** Hit the daemon's HTTP /healthz endpoint. Returns true if it responds
  *  with HTTP 200 within the timeout — false on connection refused, timeout,
  *  or any other error. */
-export async function isHttpHealthy(): Promise<boolean> {
+async function isHttpHealthy(): Promise<boolean> {
   const host = healthCheckHost(getRuntimeHttpHost());
   const port = getRuntimeHttpPort();
   try {
@@ -339,7 +339,7 @@ export async function startDaemon(): Promise<{
   }
 }
 
-async function startDaemonLocked(): Promise<{
+export async function startDaemonLocked(): Promise<{
   pid: number;
   alreadyRunning: boolean;
 }> {