@vellumai/assistant 0.7.2 → 0.7.3

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

@@ -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";
@@ -135,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,
@@ -151,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,
@@ -305,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;
   /**
@@ -351,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"]);
 
@@ -385,16 +412,22 @@ 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_bash for non-host-proxy interfaces when
-      // at least one capable client is connected via the event hub.
-      // Only applies to host_bash (not host_file, host_cu, host_browser — Phase 2).
-      // Excludes chrome-extension (security boundary: extension only gets host_browser)
-      // and hasNoClient turns (no interactive approval UI available).
+      // 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 === "host_bash" &&
+        capability &&
+        CROSS_CLIENT_EXPOSED_CAPABILITIES.has(capability) &&
         transport !== "chrome-extension" &&
         !ctx.hasNoClient &&
-        assistantEventHub.listClientsByCapability("host_bash").length > 0
+        assistantEventHub.listClientsByCapability(capability).length > 0
       ) {
         return true;
       }
@@ -516,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,7 @@ 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 {
@@ -136,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,
@@ -170,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>;
@@ -318,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[] = [];
@@ -358,7 +349,6 @@ export class Conversation {
     maxTokens: number | undefined,
     sendToClient: (msg: ServerMessage) => void,
     workingDir: string,
-    memoryPolicy?: ConversationMemoryPolicy,
     sharedCesClient?: CesClient,
     speedOverride?: Speed,
     cacheTtl?: "5m" | "1h",
@@ -369,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) => {
@@ -764,6 +748,11 @@ export class Conversation {
       clearTimeout(timer);
     }
     this.recentlyCompletedStandaloneSurfaces.clear();
+    // 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().
@@ -774,7 +763,6 @@ export class Conversation {
     // 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);
   }
@@ -1144,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();
+}