@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -13,12 +13,12 @@ import {
 } from "../channels/types.js";
 import { isHttpAuthDisabled } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
-import type { CesClient } from "../credential-execution/client.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 type { Message, ToolDefinition } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { coreAppProxyTools } from "../tools/apps/definitions.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -30,12 +30,13 @@ import {
   ACTIVITY_SKIP_SET,
   injectActivityField,
 } from "../tools/schema-transforms.js";
-import type {
-  ProxyApprovalCallback,
-  ProxyApprovalRequest,
-  ToolContext,
-  ToolExecutionResult,
-  ToolLifecycleEventHandler,
+import {
+  isDiskPressureCleanupToolName,
+  type ProxyApprovalCallback,
+  type ProxyApprovalRequest,
+  type ToolContext,
+  type ToolExecutionResult,
+  type ToolLifecycleEventHandler,
 } from "../tools/types.js";
 import { allUiSurfaceTools } from "../tools/ui-surface/definitions.js";
 import { getLogger } from "../util/logger.js";
@@ -43,7 +44,6 @@ import {
   projectSkillTools,
   type SkillProjectionCache,
 } from "./conversation-skill-tools.js";
-import type { SurfaceConversationContext } from "./conversation-surfaces.js";
 import { surfaceProxyResolver } from "./conversation-surfaces.js";
 import {
   isDoordashCommand,
@@ -72,49 +72,8 @@ export function resolveTrustClass(
   return trustContext?.trustClass ?? "unknown";
 }
 
-// ── Context Interface ────────────────────────────────────────────────
-
-/**
- * Subset of Conversation state that the tool executor callback reads at
- * call time (not construction time). These are captured by the
- * returned closure, so they must be live references.
- */
-export interface ToolSetupContext extends SurfaceConversationContext {
-  readonly conversationId: string;
-  assistantId?: string;
-  currentRequestId?: string;
-  workingDir: string;
-  abortController: AbortController | null;
-  /** When set, only tools in this set may execute during the current turn. */
-  allowedToolNames?: Set<string>;
-  /** Conversation memory policy used to propagate scopeId into ToolContext. */
-  memoryPolicy: { scopeId: string };
-  /** True when the conversation has no connected client (HTTP-only path). */
-  hasNoClient?: boolean;
-  /** When true, the conversation is executing a task run and must not become interactive. */
-  headlessLock?: boolean;
-  /** When set, this conversation is executing a task run. Used to retrieve ephemeral permission rules. */
-  taskRunId?: string;
-  /** Guardian runtime context for the conversation — trustClass is propagated into ToolContext for control-plane policy enforcement. */
-  trustContext?: TrustContext;
-  /** Voice/call session ID, if the conversation originates from a call. Propagated into ToolContext for scoped grant consumption. */
-  callSessionId?: string;
-  /** CES RPC client for credential execution operations. Injected when CES tools are enabled and the CES process is available. */
-  cesClient?: CesClient;
-  /** The interface ID of the connected client driving the current turn (e.g. "macos", "chrome-extension"). Propagated into ToolContext for browser backend selection. */
-  readonly transportInterface?: InterfaceId;
-
-  /** Turn-scoped flag: true when any tool call in the current turn received explicit user approval via interactive prompt. Cleared at turn end. */
-  approvedViaPromptThisTurn?: boolean;
-  /**
-   * Per-turn snapshot of the resolved inference-profile override, set by
-   * `runAgentLoopImpl`. Propagated into `ToolContext.overrideProfile` so
-   * tools that spawn nested invocations (e.g. `subagent_spawn`) can forward
-   * the override without round-tripping through a row read that would
-   * return `undefined` for the in-flight (background) subagent.
-   */
-  currentTurnOverrideProfile?: string;
-}
+import type { ToolSetupContext } from "./tool-setup-types.js";
+export type { ToolSetupContext } from "./tool-setup-types.js";
 
 // ── buildToolDefinitions ─────────────────────────────────────────────
 
@@ -177,6 +136,7 @@ export function createToolExecutor(
       taskRunId: ctx.taskRunId,
       trustClass: resolveTrustClass(ctx.trustContext),
       executionChannel: ctx.trustContext?.sourceChannel,
+      sourceActorPrincipalId: ctx.trustContext?.guardianPrincipalId,
       callSessionId: ctx.callSessionId,
       triggeredBySurfaceAction:
         ctx.surfaceActionRequestIds?.has(ctx.currentRequestId ?? "") ?? false,
@@ -193,7 +153,7 @@ export function createToolExecutor(
       onOutput,
       signal: ctx.abortController?.signal,
       allowedToolNames: ctx.allowedToolNames,
-      memoryScopeId: ctx.memoryPolicy.scopeId,
+      diskPressureCleanupModeActive: ctx.diskPressureCleanupModeActive,
       toolUseId,
       isPlatformHosted: getIsPlatform(),
       cesClient: ctx.cesClient,
@@ -258,16 +218,6 @@ export function createToolExecutor(
       // Clone to avoid mutating shared input objects
       const toolInput = { ...rawToolInput };
 
-      // Propagate outer activity when inner input lacks a valid one
-      if (
-        typeof input.activity === "string" &&
-        input.activity &&
-        (typeof toolInput.activity !== "string" ||
-          toolInput.activity.length === 0)
-      ) {
-        toolInput.activity = input.activity;
-      }
-
       if (!toolName) {
         return {
           content:
@@ -357,6 +307,8 @@ export interface SkillProjectionContext {
   readonly hasNoClient?: boolean;
   /** When set, only tools in this set are included in the resolved tool list (subagent delegation). */
   subagentAllowedTools?: Set<string>;
+  /** True when the current turn is restricted to disk-pressure cleanup-safe tools. */
+  diskPressureCleanupModeActive?: boolean;
   /** True when this conversation belongs to a subagent spawned by SubagentManager. */
   readonly isSubagent?: boolean;
   /**
@@ -403,6 +355,29 @@ export const HOST_TOOL_TO_CAPABILITY = new Map<string, HostProxyCapability>([
 // Derived from HOST_TOOL_TO_CAPABILITY so the invariant "every host tool has
 // a capability mapping" is a structural fact — no runtime assertion needed.
 export const HOST_TOOL_NAMES = new Set(HOST_TOOL_TO_CAPABILITY.keys());
+/**
+ * Capabilities eligible for cross-client exposure on non-host-proxy
+ * transports (e.g. web, ios routing to a connected macOS client).
+ * Adding a capability here exposes ALL tools that map to it (per
+ * HOST_TOOL_TO_CAPABILITY) on non-host-proxy transports — the daemon then
+ * routes the actual invocation to the connected capable client via the
+ * proxy's targetClientId path.
+ *
+ * Inclusions:
+ * - host_bash (Phase 1, PR #29322)
+ * - host_file (Phases 2 & 3, PRs #29398 + #29440)
+ *
+ * Exclusions:
+ * - host_browser: chrome-extension is its own executor; web turns don't
+ *   have a CDP target model. Re-evaluate when host browser via macOS
+ *   host proxy ships (PR #27489).
+ * - host_app_control, host_cu: not in HOST_TOOL_TO_CAPABILITY
+ *   (skill-routed).
+ */
+const CROSS_CLIENT_EXPOSED_CAPABILITIES = new Set<HostProxyCapability>([
+  "host_bash",
+  "host_file",
+]);
 const CLIENT_CAPABILITY_TOOL_NAMES = new Set(["app_open"]);
 const PLATFORM_TOOL_NAMES = new Set(["request_system_permission"]);
 
@@ -437,6 +412,25 @@ export function isToolActiveForContext(
     // Per-capability check is authoritative for structural support: if the
     // transport cannot service this capability, the tool is filtered out.
     if (transport && capability && !supportsHostProxy(transport, capability)) {
+      // Cross-client exception: allow host tools whose capabilities have
+      // cross-client routing infrastructure (Phases 1–3) to be exposed for
+      // non-host-proxy transports (e.g. "web", "ios") when at least one
+      // capable client is connected via the event hub. Members of
+      // CROSS_CLIENT_EXPOSED_CAPABILITIES (host_bash, host_file) qualify;
+      // host_browser is intentionally excluded (chrome-extension is its
+      // own executor and web turns don't have a CDP target model).
+      // chrome-extension transport is excluded as a security boundary
+      // (extension only gets host_browser); hasNoClient turns are excluded
+      // (no interactive approval UI available).
+      if (
+        capability &&
+        CROSS_CLIENT_EXPOSED_CAPABILITIES.has(capability) &&
+        transport !== "chrome-extension" &&
+        !ctx.hasNoClient &&
+        assistantEventHub.listClientsByCapability(capability).length > 0
+      ) {
+        return true;
+      }
       return false;
     }
 
@@ -555,6 +549,16 @@ export function createResolveToolsCallback(
       }
       turnAllowed.add(name);
     }
+    if (ctx.diskPressureCleanupModeActive === true) {
+      const cleanupDefs = allBaseDefs.filter((d) =>
+        isDiskPressureCleanupToolName(d.name),
+      );
+      ctx.allowedToolNames = new Set(
+        Array.from(turnAllowed).filter(isDiskPressureCleanupToolName),
+      );
+      return injectActivityField(cleanupDefs, ACTIVITY_SKIP_SET);
+    }
+
     ctx.allowedToolNames = turnAllowed;
     return injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET);
   };

package/src/daemon/conversation.ts

@@ -106,6 +106,7 @@ import {
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
   createSurfaceMutex,
+  flushPendingSurfaceDataPersists,
   handleSurfaceAction as handleSurfaceActionImpl,
   handleSurfaceUndo as handleSurfaceUndoImpl,
   type SurfaceActionResult,
@@ -117,6 +118,8 @@ import {
   createToolExecutor,
 } from "./conversation-tool-setup.js";
 import { refreshWorkspaceTopLevelContextIfNeeded as refreshWorkspaceImpl } from "./conversation-workspace.js";
+import { canonicalizeTimeZone } from "./date-context.js";
+import type { HostAppControlProxy } from "./host-app-control-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
 import type {
   ServerMessage,
@@ -135,17 +138,6 @@ import { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("conversation");
 
-export interface ConversationMemoryPolicy {
-  scopeId: string;
-  includeDefaultFallback: boolean;
-}
-
-export const DEFAULT_MEMORY_POLICY: Readonly<ConversationMemoryPolicy> =
-  Object.freeze({
-    scopeId: "default",
-    includeDefaultFallback: false,
-  });
-
 export { findLastUndoableUserMessageIndex } from "./conversation-history.js";
 export type {
   QueueDrainReason,
@@ -169,6 +161,7 @@ export class Conversation {
   /** @internal */ eventBus = new EventBus<AssistantDomainEvents>();
   /** @internal */ workingDir: string;
   /** @internal */ allowedToolNames?: Set<string>;
+  /** @internal */ diskPressureCleanupModeActive?: boolean;
   /** @internal */ toolsDisabledDepth = 0;
   /** @internal */ preactivatedSkillIds?: string[];
   /** @internal */ subagentAllowedTools?: Set<string>;
@@ -204,6 +197,14 @@ export class Conversation {
   /** @internal */ taskRunId?: string;
   /** @internal */ callSessionId?: string;
   /** @internal */ hostCuProxy?: HostCuProxy;
+  /**
+   * Per-conversation host app-control proxy. Set via
+   * `setHostAppControlProxy` and disposed in `dispose()`. The
+   * `/v1/host-app-control-result` route forwards result payloads to the
+   * awaiting promise via this reference.
+   * @internal
+   */
+  hostAppControlProxy?: HostAppControlProxy;
   /** @internal */ cesClient?: CesClient;
   /** @internal */ readonly queue = new MessageQueue();
   /** @internal */ currentActiveSurfaceId?: string;
@@ -309,12 +310,11 @@ export class Conversation {
    * @internal
    */
   hostUsername?: string;
+  /** @internal */ clientTimezone?: string;
   public readonly traceEmitter: TraceEmitter;
   /** @internal */ hasSystemPromptOverride: boolean;
-  public memoryPolicy: ConversationMemoryPolicy;
   /** @internal */ readonly graphMemory: ConversationGraphMemory;
   /** @internal */ activeContextNodeIds?: string[];
-  /** @internal */ memoryScopeId?: string;
   /** @internal */ streamThinking: boolean;
   /** @internal */ turnCount = 0;
   public lastAssistantAttachments: AssistantAttachmentDraft[] = [];
@@ -349,7 +349,6 @@ export class Conversation {
     maxTokens: number | undefined,
     sendToClient: (msg: ServerMessage) => void,
     workingDir: string,
-    memoryPolicy?: ConversationMemoryPolicy,
     sharedCesClient?: CesClient,
     speedOverride?: Speed,
     cacheTtl?: "5m" | "1h",
@@ -360,13 +359,7 @@ export class Conversation {
     this.provider = provider;
     this.workingDir = workingDir;
     this.sendToClient = sendToClient;
-    this.memoryPolicy = memoryPolicy
-      ? { ...memoryPolicy }
-      : { ...DEFAULT_MEMORY_POLICY };
-    this.graphMemory = new ConversationGraphMemory(
-      this.memoryPolicy.scopeId,
-      conversationId,
-    );
+    this.graphMemory = new ConversationGraphMemory(conversationId);
     this.traceEmitter = new TraceEmitter(conversationId, sendToClient);
     this.prompter = new PermissionPrompter(sendToClient);
     this.prompter.setOnStateChanged((requestId, state, source, toolUseId) => {
@@ -755,14 +748,21 @@ export class Conversation {
       clearTimeout(timer);
     }
     this.recentlyCompletedStandaloneSurfaces.clear();
-    // Only dispose the per-conversation CU proxy. Bash/File/Transfer are
-    // singletons — their lifecycle is managed by static disposeInstance().
+    // Flush any pending debounced surface-data persists for this
+    // conversation so updates that arrived inside the debounce window
+    // still land in the DB before teardown. Flushing also clears the
+    // pending entries, so no separate cancel call is needed.
+    flushPendingSurfaceDataPersists(this.conversationId);
+    // Only dispose the per-conversation CU and app-control proxies.
+    // Bash/File/Transfer are singletons — their lifecycle is managed by
+    // static disposeInstance().
     this.hostCuProxy?.dispose();
+    this.hostAppControlProxy?.dispose();
+    this.hostAppControlProxy = undefined;
     // CES client is owned by DaemonServer — just drop the reference.
     // Do NOT close it here; the server manages the CES lifecycle.
     this.cesClient = undefined;
     this.activeContextNodeIds = this.graphMemory.tracker.getActiveNodeIds();
-    this.memoryScopeId = this.memoryPolicy.scopeId;
     this.graphMemory.persistState();
     disposeConversation(this);
   }
@@ -936,6 +936,13 @@ export class Conversation {
     this.hostCuProxy = proxy;
   }
 
+  setHostAppControlProxy(proxy: HostAppControlProxy | undefined): void {
+    if (this.hostAppControlProxy && this.hostAppControlProxy !== proxy) {
+      this.hostAppControlProxy.dispose();
+    }
+    this.hostAppControlProxy = proxy;
+  }
+
   // ── Server-authoritative state signals ─────────────────────────────
 
   emitConfirmationStateChanged(
@@ -1125,6 +1132,13 @@ export class Conversation {
     }
   }
 
+  applyClientTimezoneFromTransport(
+    transport: ConversationTransportMetadata,
+  ): void {
+    this.clientTimezone =
+      canonicalizeTimeZone(transport.clientTimezone) ?? undefined;
+  }
+
   setAssistantId(assistantId: string | null): void {
     this.assistantId = assistantId ?? undefined;
   }

package/src/daemon/date-context.ts

@@ -14,10 +14,31 @@ export interface TemporalContextOptions {
   hostTimeZone?: string;
   /** IANA timezone configured in user settings (if available). */
   configuredUserTimeZone?: string | null;
-  /** IANA timezone inferred from user profile/memory (if available). */
+  /** IANA timezone reported by the active client for the current turn. */
+  clientTimezone?: string | null;
+  /** IANA timezone persisted from prior client environment detection. */
+  detectedTimezone?: string | null;
+  /** Profile timezone candidate accepted by legacy callers; not used for turn resolution. */
   userTimeZone?: string | null;
 }
 
+export type TurnTimezoneSource =
+  | "timeZone"
+  | "configuredUserTimezone"
+  | "clientTimezone"
+  | "detectedTimezone"
+  | "hostTimezone"
+  | "utcFallback";
+
+export interface TurnTimezoneContext {
+  configuredUserTimezone: string | null;
+  clientTimezone: string | null;
+  detectedTimezone: string | null;
+  hostTimezone: string | null;
+  effectiveTimezone: string;
+  source: TurnTimezoneSource;
+}
+
 const WEEKDAY_LONG = [
   "Sunday",
   "Monday",
@@ -86,7 +107,12 @@ function canonicalizeUtcGmtOffsetToken(offsetToken: string): string | null {
   ).padStart(2, "0")}`;
 }
 
-function canonicalizeTimeZone(timeZone: string): string | null {
+export function canonicalizeTimeZone(
+  timeZone: string | null | undefined,
+): string | null {
+  if (timeZone == null) {
+    return null;
+  }
   const trimmed = timeZone.trim();
   if (trimmed.length === 0) {
     return null;
@@ -121,6 +147,17 @@ function canonicalizeTimeZone(timeZone: string): string | null {
   }
 }
 
+function firstResolvedTimezone(
+  candidates: Array<[TurnTimezoneSource, string | null]>,
+): { source: TurnTimezoneSource; timeZone: string } | null {
+  for (const [source, timeZone] of candidates) {
+    if (timeZone) {
+      return { source, timeZone };
+    }
+  }
+  return null;
+}
+
 /**
  * Common timezone abbreviation → IANA identifier mapping.
  * Used as a fallback when `Intl.DateTimeFormat` does not recognize the abbreviation.
@@ -289,11 +326,41 @@ function formatLocalDate(date: Date, timeZone: string): string {
   ).padStart(2, "0")}`;
 }
 
+export function resolveTurnTimezoneContext(
+  options: TemporalContextOptions = {},
+): TurnTimezoneContext {
+  const configuredUserTimezone = canonicalizeTimeZone(
+    options.configuredUserTimeZone,
+  );
+  const clientTimezone = canonicalizeTimeZone(options.clientTimezone);
+  const detectedTimezone = canonicalizeTimeZone(options.detectedTimezone);
+  const hostTimezone = canonicalizeTimeZone(
+    options.hostTimeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
+  );
+  const explicitTimezone = canonicalizeTimeZone(options.timeZone);
+  const selected = firstResolvedTimezone([
+    ["timeZone", explicitTimezone],
+    ["configuredUserTimezone", configuredUserTimezone],
+    ["clientTimezone", clientTimezone],
+    ["detectedTimezone", detectedTimezone],
+    ["hostTimezone", hostTimezone],
+  ]);
+
+  return {
+    configuredUserTimezone,
+    clientTimezone,
+    detectedTimezone,
+    hostTimezone,
+    effectiveTimezone: selected?.timeZone ?? "UTC",
+    source: selected?.source ?? "utcFallback",
+  };
+}
+
 /**
  * Format time as HH:MM:SS with UTC offset and timezone name.
  *
  * Uses the timezone resolution cascade:
- * explicit override → configured user tz → profile user tz → host fallback.
+ * explicit override → configured user tz → client tz → detected tz → host fallback.
  *
  * Returns format: `2026-04-02 (Thursday) 01:52:33 -05:00 (America/Chicago)`
  */
@@ -301,24 +368,7 @@ export function formatTurnTimestamp(
   options: TemporalContextOptions = {},
 ): string {
   const now = new Date(options.nowMs ?? Date.now());
-  const resolvedHostTimeZone =
-    canonicalizeTimeZone(
-      options.hostTimeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
-    ) ?? "UTC";
-  const resolvedConfiguredUserTimeZone = options.configuredUserTimeZone
-    ? canonicalizeTimeZone(options.configuredUserTimeZone)
-    : null;
-  const resolvedUserTimeZone = options.userTimeZone
-    ? canonicalizeTimeZone(options.userTimeZone)
-    : null;
-  const resolvedTimeZone = options.timeZone
-    ? canonicalizeTimeZone(options.timeZone)
-    : null;
-  const timeZone =
-    resolvedTimeZone ??
-    resolvedConfiguredUserTimeZone ??
-    resolvedUserTimeZone ??
-    resolvedHostTimeZone;
+  const timeZone = resolveTurnTimezoneContext(options).effectiveTimezone;
 
   const dateStr = formatLocalDate(now, timeZone);
   const todayParts = localDateParts(now, timeZone);
@@ -341,4 +391,3 @@ export function formatTurnTimestamp(
 
   return `${dateStr} (${dayName}) ${hour}:${minute}:${second} ${offset} (${timeZone})`;
 }
-

package/src/daemon/disk-pressure-background-gate.ts

@@ -0,0 +1,73 @@
+import {
+  type DiskPressureBlockedCapability,
+  type DiskPressureStatus,
+  getDiskPressureStatus,
+} from "./disk-pressure-guard.js";
+
+export type DiskPressureBackgroundGateDecision =
+  | { action: "allow"; status: DiskPressureStatus }
+  | {
+      action: "skip";
+      reason: "disk_pressure";
+      status: DiskPressureStatus;
+      blockedCapability: DiskPressureBlockedCapability;
+    };
+
+export const DISK_PRESSURE_BACKGROUND_LOG_THROTTLE_MS = 60_000;
+
+const lastSkipLogAtByKey = new Map<string, number>();
+
+export function checkDiskPressureBackgroundGate(
+  blockedCapability: DiskPressureBlockedCapability = "background-work",
+): DiskPressureBackgroundGateDecision {
+  const status = getDiskPressureStatus();
+  if (!status.enabled || !status.locked || status.overrideActive) {
+    return { action: "allow", status };
+  }
+  if (!status.effectivelyLocked) {
+    return { action: "allow", status };
+  }
+  return {
+    action: "skip",
+    reason: "disk_pressure",
+    status,
+    blockedCapability,
+  };
+}
+
+export function shouldLogDiskPressureBackgroundSkip(
+  key: string,
+  nowMs = Date.now(),
+): boolean {
+  const lastLoggedAt = lastSkipLogAtByKey.get(key) ?? 0;
+  if (nowMs - lastLoggedAt < DISK_PRESSURE_BACKGROUND_LOG_THROTTLE_MS) {
+    return false;
+  }
+  lastSkipLogAtByKey.set(key, nowMs);
+  return true;
+}
+
+export function diskPressureBackgroundSkipLogFields(
+  decision: Extract<DiskPressureBackgroundGateDecision, { action: "skip" }>,
+): {
+  reason: "disk_pressure";
+  thresholdPercent: number;
+  usagePercent: number | null;
+  blockedCapability: DiskPressureBlockedCapability;
+  lockId: string | null;
+  path: string | null;
+} {
+  return {
+    reason: decision.reason,
+    thresholdPercent: decision.status.thresholdPercent,
+    usagePercent: decision.status.usagePercent,
+    blockedCapability: decision.blockedCapability,
+    lockId: decision.status.lockId,
+    path: decision.status.path,
+  };
+}
+
+/** @internal */
+export function __resetDiskPressureBackgroundGateForTests(): void {
+  lastSkipLogAtByKey.clear();
+}