@vellumai/assistant 0.7.2 → 0.8.0

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);
   }
@@ -1064,7 +1052,7 @@ export class Conversation {
       );
     }
     if (result.compacted) {
-      applyCompactionResult(this, result, this.sendToClient, null, {
+      await applyCompactionResult(this, result, this.sendToClient, null, {
         slackContextCompactionWatermarkTs: getSlackCompactionWatermarkForPrefix(
           slackChronologicalContext,
           result.compactedMessages,
@@ -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();
+}

package/src/daemon/disk-pressure-guard.ts

@@ -0,0 +1,343 @@
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { getConfig } from "../config/loader.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { cancelBackgroundTools } from "../tools/background-tool-registry.js";
+import { getDiskUsageInfo } from "../util/disk-usage.js";
+import { getLogger } from "../util/logger.js";
+
+export const DISK_PRESSURE_THRESHOLD_PERCENT = 95;
+export const DISK_PRESSURE_CHECK_INTERVAL_MS = 60_000;
+export const DISK_PRESSURE_OVERRIDE_CONFIRMATION = "I understand the risks";
+export const DISK_PRESSURE_BLOCKED_CAPABILITIES = [
+  "agent-turns",
+  "background-work",
+  "remote-ingress",
+] as const;
+
+export type DiskPressureState = "disabled" | "ok" | "critical" | "unknown";
+
+export type DiskPressureBlockedCapability =
+  (typeof DISK_PRESSURE_BLOCKED_CAPABILITIES)[number];
+
+export interface DiskPressureStatus {
+  enabled: boolean;
+  state: DiskPressureState;
+  locked: boolean;
+  acknowledged: boolean;
+  overrideActive: boolean;
+  effectivelyLocked: boolean;
+  lockId: string | null;
+  usagePercent: number | null;
+  thresholdPercent: number;
+  path: string | null;
+  lastCheckedAt: string | null;
+  blockedCapabilities: DiskPressureBlockedCapability[];
+  error: string | null;
+}
+
+export type DiskPressureTransitionResult =
+  | { ok: true; status: DiskPressureStatus }
+  | {
+      ok: false;
+      reason:
+        | "not_locked"
+        | "already_acknowledged"
+        | "already_overridden"
+        | "invalid_confirmation";
+      message: string;
+      status: DiskPressureStatus;
+    };
+
+interface DiskPressureGuardState {
+  timer: ReturnType<typeof setInterval> | null;
+  status: DiskPressureStatus;
+}
+
+const log = getLogger("disk-pressure-guard");
+
+const DISABLED_STATUS: DiskPressureStatus = {
+  enabled: false,
+  state: "disabled",
+  locked: false,
+  acknowledged: false,
+  overrideActive: false,
+  effectivelyLocked: false,
+  lockId: null,
+  usagePercent: null,
+  thresholdPercent: DISK_PRESSURE_THRESHOLD_PERCENT,
+  path: null,
+  lastCheckedAt: null,
+  blockedCapabilities: [],
+  error: null,
+};
+
+const OPEN_STATUS: DiskPressureStatus = {
+  ...DISABLED_STATUS,
+  enabled: true,
+  state: "ok",
+  thresholdPercent: DISK_PRESSURE_THRESHOLD_PERCENT,
+};
+
+const state: DiskPressureGuardState = {
+  timer: null,
+  status: cloneStatus(DISABLED_STATUS),
+};
+
+function cloneStatus(status: DiskPressureStatus): DiskPressureStatus {
+  return {
+    ...status,
+    blockedCapabilities: [...status.blockedCapabilities],
+  };
+}
+
+function statusFingerprint(status: DiskPressureStatus): string {
+  const { lastCheckedAt: _lastCheckedAt, ...substantiveStatus } = status;
+  return JSON.stringify(substantiveStatus);
+}
+
+function publishStatusChangedIfNeeded(previous: DiskPressureStatus): void {
+  if (statusFingerprint(previous) === statusFingerprint(state.status)) return;
+  const status = cloneStatus(state.status);
+  assistantEventHub
+    .publish(
+      buildAssistantEvent({
+        type: "disk_pressure_status_changed",
+        status,
+      }),
+    )
+    .catch((err) => {
+      log.warn({ err }, "Failed to publish disk pressure status change");
+    });
+}
+
+function replaceStatus(next: DiskPressureStatus): DiskPressureStatus {
+  const previous = cloneStatus(state.status);
+  state.status = cloneStatus(next);
+  publishStatusChangedIfNeeded(previous);
+  return cloneStatus(state.status);
+}
+
+function isEnabled(): boolean {
+  return isAssistantFeatureFlagEnabled("safe-storage-limits", getConfig());
+}
+
+function resetToDisabled(): DiskPressureStatus {
+  const previous = cloneStatus(state.status);
+  stopDiskPressureGuard();
+  state.status = cloneStatus(DISABLED_STATUS);
+  publishStatusChangedIfNeeded(previous);
+  return cloneStatus(state.status);
+}
+
+function ensureEnabledStatus(): DiskPressureStatus | null {
+  if (!isEnabled()) return resetToDisabled();
+  if (!state.status.enabled) {
+    state.status = cloneStatus(OPEN_STATUS);
+  }
+  return null;
+}
+
+function nextLockId(): string {
+  return `disk-pressure-${Date.now()}`;
+}
+
+function roundPercent(value: number): number {
+  return Math.round(value * 100) / 100;
+}
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function sampleFailureStatus(error: unknown): DiskPressureStatus {
+  const now = new Date().toISOString();
+  return {
+    ...state.status,
+    enabled: true,
+    state: "unknown",
+    locked: false,
+    acknowledged: false,
+    overrideActive: false,
+    effectivelyLocked: false,
+    lockId: null,
+    usagePercent: null,
+    thresholdPercent: DISK_PRESSURE_THRESHOLD_PERCENT,
+    path: null,
+    lastCheckedAt: now,
+    blockedCapabilities: [],
+    error: formatError(error),
+  };
+}
+
+function cancelTerminalBackgroundToolsForLock(): void {
+  const cancelled = cancelBackgroundTools(
+    (tool) => tool.toolName === "bash" || tool.toolName === "host_bash",
+    "disk_pressure",
+  );
+  if (cancelled.length === 0) return;
+  log.info(
+    { count: cancelled.length, ids: cancelled.map((tool) => tool.id) },
+    "Cancelled background terminal tools during disk pressure lock",
+  );
+}
+
+function rejectTransition(
+  reason: Exclude<DiskPressureTransitionResult, { ok: true }>["reason"],
+  message: string,
+  status: DiskPressureStatus,
+): DiskPressureTransitionResult {
+  return { ok: false, reason, message, status };
+}
+
+export function startDiskPressureGuard(): DiskPressureStatus {
+  const disabledStatus = ensureEnabledStatus();
+  if (disabledStatus) return disabledStatus;
+
+  if (!state.timer) {
+    state.timer = setInterval(() => {
+      void evaluateDiskPressureNow();
+    }, DISK_PRESSURE_CHECK_INTERVAL_MS);
+    (state.timer as { unref?: () => void }).unref?.();
+  }
+
+  return cloneStatus(state.status);
+}
+
+export function stopDiskPressureGuard(): void {
+  if (!state.timer) return;
+  clearInterval(state.timer);
+  state.timer = null;
+}
+
+export function evaluateDiskPressureNow(): DiskPressureStatus {
+  const disabledStatus = ensureEnabledStatus();
+  if (disabledStatus) return disabledStatus;
+
+  let usageInfo: ReturnType<typeof getDiskUsageInfo>;
+  try {
+    usageInfo = getDiskUsageInfo();
+  } catch (error) {
+    return replaceStatus(sampleFailureStatus(error));
+  }
+
+  if (!usageInfo || usageInfo.totalMb <= 0) {
+    return replaceStatus(sampleFailureStatus("Disk usage sample unavailable"));
+  }
+
+  const usagePercent = roundPercent(
+    (usageInfo.usedMb / usageInfo.totalMb) * 100,
+  );
+  const isCritical = usagePercent >= DISK_PRESSURE_THRESHOLD_PERCENT;
+  const lastCheckedAt = new Date().toISOString();
+
+  if (!isCritical) {
+    return replaceStatus({
+      ...OPEN_STATUS,
+      usagePercent,
+      path: usageInfo.path,
+      lastCheckedAt,
+    });
+  }
+
+  if (!state.status.locked) {
+    cancelTerminalBackgroundToolsForLock();
+  }
+
+  const lockId = state.status.locked ? state.status.lockId : nextLockId();
+  return replaceStatus({
+    enabled: true,
+    state: "critical",
+    locked: true,
+    acknowledged: state.status.locked ? state.status.acknowledged : false,
+    overrideActive: state.status.locked ? state.status.overrideActive : false,
+    effectivelyLocked: state.status.locked
+      ? !state.status.overrideActive
+      : true,
+    lockId,
+    usagePercent,
+    thresholdPercent: DISK_PRESSURE_THRESHOLD_PERCENT,
+    path: usageInfo.path,
+    lastCheckedAt,
+    blockedCapabilities: [...DISK_PRESSURE_BLOCKED_CAPABILITIES],
+    error: null,
+  });
+}
+
+export function getDiskPressureStatus(): DiskPressureStatus {
+  if (!isEnabled()) return cloneStatus(DISABLED_STATUS);
+  if (!state.status.enabled) return cloneStatus(OPEN_STATUS);
+  return cloneStatus(state.status);
+}
+
+export function acknowledgeDiskPressureLock(): DiskPressureTransitionResult {
+  const disabledStatus = ensureEnabledStatus();
+  const status = disabledStatus ?? cloneStatus(state.status);
+  if (!status.locked) {
+    return rejectTransition(
+      "not_locked",
+      "No disk pressure lock is active for this assistant.",
+      status,
+    );
+  }
+
+  if (status.acknowledged) {
+    return rejectTransition(
+      "already_acknowledged",
+      "The disk pressure lock has already been acknowledged.",
+      status,
+    );
+  }
+
+  const previous = cloneStatus(state.status);
+  state.status.acknowledged = true;
+  publishStatusChangedIfNeeded(previous);
+  return { ok: true, status: cloneStatus(state.status) };
+}
+
+export function overrideDiskPressureLock(
+  confirmation: string,
+): DiskPressureTransitionResult {
+  const disabledStatus = ensureEnabledStatus();
+  const status = disabledStatus ?? cloneStatus(state.status);
+  if (!status.locked) {
+    return rejectTransition(
+      "not_locked",
+      "No disk pressure lock is active for this assistant.",
+      status,
+    );
+  }
+
+  if (status.overrideActive) {
+    return rejectTransition(
+      "already_overridden",
+      "The disk pressure lock has already been overridden.",
+      status,
+    );
+  }
+
+  if (confirmation.trim() !== DISK_PRESSURE_OVERRIDE_CONFIRMATION) {
+    return rejectTransition(
+      "invalid_confirmation",
+      `Type "${DISK_PRESSURE_OVERRIDE_CONFIRMATION}" to resume normal assistant behavior.`,
+      status,
+    );
+  }
+
+  const previous = cloneStatus(state.status);
+  state.status.overrideActive = true;
+  state.status.effectivelyLocked = false;
+  publishStatusChangedIfNeeded(previous);
+  return { ok: true, status: cloneStatus(state.status) };
+}
+
+export function __resetDiskPressureGuardForTests(): void {
+  stopDiskPressureGuard();
+  state.status = cloneStatus(DISABLED_STATUS);
+}
+
+export function __getDiskPressureGuardTimerForTests(): ReturnType<
+  typeof setInterval
+> | null {
+  return state.timer;
+}