@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/daemon/conversation.ts

@@ -17,6 +17,7 @@
 
 import type { AgentLoopConfig, ResolvedSystemPrompt } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
+import type { AssistantActivityStateEvent } from "../api/events/assistant-activity-state.js";
 import type {
   InterfaceId,
   TurnChannelContext,
@@ -51,7 +52,6 @@ import { registerToolTraceListener } from "../events/tool-trace-listener.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import {
   getConversation,
-  getConversationOriginChannel,
   getConversationOverrideProfileFromRow,
   setConversationHistoryStrippedAt,
 } from "../memory/conversation-crud.js";
@@ -67,6 +67,7 @@ import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
+import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
 import { ToolExecutor } from "../tools/executor.js";
 import { getAllToolDefinitions } from "../tools/registry.js";
 import type { ToolLifecycleEvent } from "../tools/types.js";
@@ -74,10 +75,10 @@ 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 type { AssistantSurface } from "./conversation-agent-loop.js";
 import {
   applyCompactionResult,
   runAgentLoopImpl,
-  trackCompactionOutcome,
 } from "./conversation-agent-loop.js";
 import type { HistoryConversationContext } from "./conversation-history.js";
 import { undo as undoImpl } from "./conversation-history.js";
@@ -98,7 +99,10 @@ import {
 } from "./conversation-messaging.js";
 // Extracted modules
 import { registerConversationNotifiers } from "./conversation-notifiers.js";
-import type { ProcessConversationContext } from "./conversation-process.js";
+import type {
+  ProcessConversationContext,
+  ProcessMessageOptions,
+} from "./conversation-process.js";
 import {
   drainQueue as drainQueueImpl,
   processMessage as processMessageImpl,
@@ -123,9 +127,7 @@ import type { ToolSetupContext } from "./conversation-tool-setup.js";
 import {
   createResolveToolsCallback,
   createToolExecutor,
-  resolveTrustClass,
 } from "./conversation-tool-setup.js";
-import { refreshWorkspaceTopLevelContextIfNeeded as refreshWorkspaceImpl } from "./conversation-workspace.js";
 import { canonicalizeTimeZone } from "./date-context.js";
 import { HostAppControlProxy } from "./host-app-control-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
@@ -135,14 +137,11 @@ import type {
   SurfaceData,
   SurfaceType,
   UsageStats,
-  UserMessageAttachment,
 } from "./message-protocol.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import { isHostProxyTransport } from "./message-types/conversations.js";
-import type {
-  AssistantActivityState,
-  ConfirmationStateChanged,
-} from "./message-types/messages.js";
+import type { ConfirmationStateChanged } from "./message-types/messages.js";
+import { conversationMetadataSyncTag } from "./message-types/sync.js";
 import { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("conversation");
@@ -159,14 +158,22 @@ export type {
   QueueDrainReason,
   QueuePolicy,
 } from "./conversation-queue-manager.js";
-import type { TrustContext } from "./trust-context.js";
+import { resolveTrustClass, type TrustContext } from "./trust-context.js";
+
+export interface ConversationConstructorOptions {
+  maxTokens?: number;
+  sharedCesClient?: CesClient;
+  speedOverride?: Speed;
+  cacheTtl?: "5m" | "1h";
+  modelOverride?: string;
+}
 
 export class Conversation {
   public readonly conversationId: string;
   /** @internal */ provider: Provider;
   /** @internal */ messages: Message[] = [];
   /** @internal */ agentLoop: AgentLoop;
-  /** @internal */ processing = false;
+  private _processing = false;
   private stale = false;
   /** @internal */ abortController: AbortController | null = null;
   /** @internal */ prompter: PermissionPrompter;
@@ -204,19 +211,6 @@ export class Conversation {
    * stripped and never re-emits them.
    */
   /** @internal */ pendingPostCompactReinject = false;
-  /**
-   * Tracks consecutive compaction failures (summary LLM call threw). In-memory
-   * only — resets to 0 on process restart, which is the intended "one free
-   * retry after restart" behavior. Reset to 0 on any successful compaction.
-   */
-  /** @internal */ consecutiveCompactionFailures = 0;
-  /**
-   * When the circuit breaker is open, this timestamp (ms since epoch) marks
-   * when auto-compaction is allowed to resume. Set to `Date.now() + 1h` after
-   * 3 consecutive failures; cleared on a successful compaction. User-initiated
-   * compaction (`force: true`) bypasses the breaker regardless.
-   */
-  /** @internal */ compactionCircuitOpenUntil: number | null = null;
   /** @internal */ currentRequestId?: string;
   /** @internal */ hasNoClient = false;
   /** @internal */ isSubagent = false;
@@ -325,20 +319,7 @@ export class Conversation {
     ReturnType<typeof setTimeout>
   >();
   /** @internal */ withSurface = createSurfaceMutex();
-  /** @internal */ currentTurnSurfaces: Array<{
-    surfaceId: string;
-    surfaceType: SurfaceType;
-    title?: string;
-    data: SurfaceData;
-    actions?: Array<{
-      id: string;
-      label: string;
-      style?: string;
-      data?: Record<string, unknown>;
-    }>;
-    display?: string;
-    persistent?: boolean;
-  }> = [];
+  /** @internal */ currentTurnSurfaces: AssistantSurface[] = [];
   /** @internal */ workspaceTopLevelContext: string | null = null;
   /** @internal */ workspaceTopLevelDirty = true;
   /**
@@ -384,7 +365,6 @@ export class Conversation {
   onConfirmationOutcome?: (
     requestId: string,
     state: string,
-    toolName?: string,
     toolUseId?: string,
   ) => void;
   private cacheWarmAbort?: AbortController;
@@ -393,14 +373,17 @@ export class Conversation {
     conversationId: string,
     provider: Provider,
     systemPrompt: string,
-    maxTokens: number | undefined,
     sendToClient: (msg: ServerMessage) => void,
     workingDir: string,
-    sharedCesClient?: CesClient,
-    speedOverride?: Speed,
-    cacheTtl?: "5m" | "1h",
-    modelOverride?: string,
+    options?: ConversationConstructorOptions,
   ) {
+    const {
+      maxTokens,
+      sharedCesClient,
+      speedOverride,
+      cacheTtl,
+      modelOverride,
+    } = options ?? {};
     this.conversationId = conversationId;
     this.systemPrompt = systemPrompt;
     this.provider = provider;
@@ -421,22 +404,17 @@ export class Conversation {
       });
       // Notify the agent loop so it can track requestId → toolUseId mappings
       // and record confirmation outcomes for persistence.
-      this.onConfirmationOutcome?.(requestId, state, undefined, toolUseId);
+      this.onConfirmationOutcome?.(requestId, state, toolUseId);
       // Emit activity state transitions for confirmation lifecycle
       if (state === "pending") {
         this.emitActivityState(
           "awaiting_confirmation",
           "confirmation_requested",
-          "assistant_turn",
         );
       } else if (state === "timed_out") {
-        this.emitActivityState(
-          "thinking",
-          "confirmation_resolved",
-          "assistant_turn",
-          undefined,
-          "Resuming after timeout",
-        );
+        this.emitActivityState("thinking", "confirmation_resolved", {
+          statusText: "Resuming after timeout",
+        });
       }
     });
     this.secretPrompter = new SecretPrompter();
@@ -539,15 +517,14 @@ export class Conversation {
       agentLoopConfig.maxTokens = configuredMaxTokens;
     }
 
-    this.agentLoop = new AgentLoop(
-      provider,
-      systemPrompt,
-      agentLoopConfig,
-      toolDefs.length > 0 ? toolDefs : undefined,
-      toolDefs.length > 0 ? toolExecutor : undefined,
+    this.agentLoop = new AgentLoop(provider, systemPrompt, {
+      conversationId: this.conversationId,
+      config: agentLoopConfig,
+      tools: toolDefs.length > 0 ? toolDefs : undefined,
+      toolExecutor: toolDefs.length > 0 ? toolExecutor : undefined,
       resolveTools,
-      resolveSystemPromptCallback,
-    );
+      resolveSystemPrompt: resolveSystemPromptCallback,
+    });
     this.contextWindowManager = new ContextWindowManager({
       provider,
       systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
@@ -599,7 +576,9 @@ export class Conversation {
     };
 
     provider
-      .sendMessage([warmMessage], tools, systemPrompt, {
+      .sendMessage([warmMessage], {
+        tools,
+        systemPrompt,
         config: {
           max_tokens: 1,
           callSite: "mainAgent",
@@ -753,7 +732,30 @@ export class Conversation {
   }
 
   isProcessing(): boolean {
-    return this.processing;
+    return this._processing;
+  }
+
+  /**
+   * Mutate the server-authoritative `processing` flag. Web/Capacitor/CLI
+   * caches treat this flag as the source of truth for the avatar streaming
+   * ring and thinking indicator, so the `true → false` clear must announce
+   * itself: the daemon flips it in the agent-loop `finally` (after an awaited
+   * turn-boundary commit), which is later than the user-visible terminal SSE
+   * events, and a racing metadata refetch can otherwise re-read the
+   * not-yet-cleared `true` and clobber the client's optimistic `false`.
+   *
+   * Emitting a metadata invalidation on the clear lets every client GET the
+   * authoritative `false`, per the multi-client-sync contract in AGENTS.md
+   * ("emit the invalidation after the canonical state write succeeds").
+   */
+  setProcessing(value: boolean): void {
+    const wasProcessing = this._processing;
+    this._processing = value;
+    if (wasProcessing && !value) {
+      void publishSyncInvalidation([
+        conversationMetadataSyncTag(this.conversationId),
+      ]);
+    }
   }
 
   markStale(): void {
@@ -815,6 +817,7 @@ export class Conversation {
     this.cesClient = undefined;
     this.activeContextNodeIds = this.graphMemory.tracker.getActiveNodeIds();
     this.graphMemory.persistState();
+    this.graphMemory.dispose();
     disposeConversation(this);
   }
 
@@ -856,7 +859,7 @@ export class Conversation {
   }
 
   canHandoffAtCheckpoint(): boolean {
-    return this.processing && this.hasQueuedMessages();
+    return this._processing && this.hasQueuedMessages();
   }
 
   hasPendingConfirmation(requestId: string): boolean {
@@ -878,13 +881,15 @@ export class Conversation {
   handleConfirmationResponse(
     requestId: string,
     decision: UserDecision,
-    selectedPattern?: string,
-    selectedScope?: string,
-    decisionContext?: string,
-    emissionContext?: {
-      source?: ConfirmationStateChanged["source"];
-      causedByRequestId?: string;
-      decisionText?: string;
+    options?: {
+      selectedPattern?: string;
+      selectedScope?: string;
+      decisionContext?: string;
+      emissionContext?: {
+        source?: ConfirmationStateChanged["source"];
+        causedByRequestId?: string;
+        decisionText?: string;
+      };
     },
   ): void {
     // Guard: only proceed if the confirmation is still pending. Stale or
@@ -893,53 +898,38 @@ export class Conversation {
       return;
     }
 
-    const effectiveDecision = decision;
-
     // Capture toolUseId before resolving (resolution deletes the pending entry)
     const toolUseId = this.prompter.getToolUseId(requestId);
 
-    this.prompter.resolveConfirmation(
-      requestId,
-      effectiveDecision,
-      selectedPattern,
-      selectedScope,
-      decisionContext,
-    );
+    this.prompter.resolveConfirmation(requestId, decision, {
+      selectedPattern: options?.selectedPattern,
+      selectedScope: options?.selectedScope,
+      decisionContext: options?.decisionContext,
+    });
 
     // 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"
-        ? ("denied" as const)
-        : ("approved" as const);
+      decision === "deny" ? ("denied" as const) : ("approved" as const);
     this.emitConfirmationStateChanged({
       conversationId: this.conversationId,
       requestId,
       state: resolvedState,
-      source: emissionContext?.source ?? "button",
+      source: options?.emissionContext?.source ?? "button",
       toolUseId,
-      ...(emissionContext?.causedByRequestId
-        ? { causedByRequestId: emissionContext.causedByRequestId }
+      ...(options?.emissionContext?.causedByRequestId
+        ? { causedByRequestId: options.emissionContext.causedByRequestId }
         : {}),
-      ...(emissionContext?.decisionText
-        ? { decisionText: emissionContext.decisionText }
+      ...(options?.emissionContext?.decisionText
+        ? { decisionText: options.emissionContext.decisionText }
         : {}),
     });
     // Notify the agent loop of the confirmation outcome for persistence
-    this.onConfirmationOutcome?.(
-      requestId,
-      resolvedState,
-      undefined,
-      toolUseId,
-    );
-    this.emitActivityState(
-      "thinking",
-      "confirmation_resolved",
-      "assistant_turn",
-      undefined,
-      "Resuming after approval",
-    );
+    this.onConfirmationOutcome?.(requestId, resolvedState, toolUseId);
+    this.emitActivityState("thinking", "confirmation_resolved", {
+      statusText: "Resuming after approval",
+    });
 
     // Sync the canonical guardian request status so stale "pending" DB
     // records don't get matched by later guardian reply routing. Best-effort:
@@ -978,15 +968,24 @@ export class Conversation {
 
   ensureHostProxiesForTurn(
     sourceInterface: import("../channels/types.js").InterfaceId | undefined,
+    sourceActorPrincipalId = this.trustContext?.guardianPrincipalId,
   ): void {
     if (
-      shouldAttachHostProxyForCapability("host_cu", sourceInterface) &&
+      shouldAttachHostProxyForCapability(
+        "host_cu",
+        sourceInterface,
+        sourceActorPrincipalId,
+      ) &&
       !this.hostCuProxy
     ) {
       this.setHostCuProxy(new HostCuProxy());
     }
     if (
-      shouldAttachHostProxyForCapability("host_app_control", sourceInterface) &&
+      shouldAttachHostProxyForCapability(
+        "host_app_control",
+        sourceInterface,
+        sourceActorPrincipalId,
+      ) &&
       !this.hostAppControlProxy
     ) {
       this.setHostAppControlProxy(new HostAppControlProxy(this.conversationId));
@@ -1013,12 +1012,15 @@ export class Conversation {
   }
 
   emitActivityState(
-    phase: AssistantActivityState["phase"],
-    reason: AssistantActivityState["reason"],
-    anchor: AssistantActivityState["anchor"] = "assistant_turn",
-    requestId?: string,
-    statusText?: string,
+    phase: AssistantActivityStateEvent["phase"],
+    reason: AssistantActivityStateEvent["reason"],
+    options?: {
+      anchor?: AssistantActivityStateEvent["anchor"];
+      requestId?: string;
+      statusText?: string;
+    },
   ): void {
+    const { anchor = "assistant_turn", requestId, statusText } = options ?? {};
     this.activityVersion++;
     const msg: ServerMessage = {
       type: "assistant_activity_state",
@@ -1041,9 +1043,7 @@ export class Conversation {
     }
   }
 
-  async forceCompact(options?: {
-    targetInputTokensOverride?: number;
-  }): Promise<ContextWindowResult> {
+  async forceCompact(): Promise<ContextWindowResult> {
     const conversationRow = getConversation(this.conversationId);
     const overrideProfile =
       getConversationOverrideProfileFromRow(conversationRow) ?? null;
@@ -1087,11 +1087,8 @@ export class Conversation {
       this.abortController?.signal ?? undefined,
       {
         force: true,
-        lastCompactedAt: this.contextCompactedAt ?? undefined,
-        conversationOriginChannel:
-          getConversationOriginChannel(this.conversationId) ?? undefined,
         overrideProfile,
-        targetInputTokensOverride: options?.targetInputTokensOverride,
+        actorTrustClass: this.trustContext?.trustClass,
       },
     );
     // Track circuit-breaker state for user-initiated `/compact` and other
@@ -1100,8 +1097,7 @@ 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) {
-      await trackCompactionOutcome(
-        this,
+      await this.agentLoop.compactionCircuit.recordOutcome(
         result.summaryFailed,
         this.sendToClient,
       );
@@ -1271,7 +1267,7 @@ export class Conversation {
   async persistUserMessage(
     options: PersistMessageOptions,
   ): Promise<{ id: string; deduplicated: boolean }> {
-    if (!this.processing) {
+    if (!this._processing) {
       await this.ensureActorScopedHistory();
     }
     return persistUserMessageImpl(this, options);
@@ -1282,8 +1278,8 @@ export class Conversation {
   async runAgentLoop(
     content: string,
     userMessageId: string,
-    onEvent?: (msg: ServerMessage) => void,
     options?: {
+      onEvent?: (msg: ServerMessage) => void;
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
@@ -1299,12 +1295,13 @@ export class Conversation {
       overrideProfile?: string;
     },
   ): Promise<void> {
+    const { onEvent, ...rest } = options ?? {};
     return runAgentLoopImpl(
       this,
       content,
       userMessageId,
       onEvent ?? this.sendToClient,
-      options,
+      rest,
     );
   }
 
@@ -1312,29 +1309,13 @@ export class Conversation {
     return drainQueueImpl(this as ProcessConversationContext, reason);
   }
 
-  async processMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    onEvent?: (msg: ServerMessage) => void,
-    requestId?: string,
-    activeSurfaceId?: string,
-    currentPage?: string,
-    options?: { isInteractive?: boolean; callSite?: LLMCallSite },
-    displayContent?: string,
-  ): Promise<string> {
+  async processMessage(options: ProcessMessageOptions): Promise<string> {
     this.cacheWarmAbort?.abort();
     this.cacheWarmAbort = undefined;
-    return processMessageImpl(
-      this as ProcessConversationContext,
-      content,
-      attachments,
-      onEvent ?? this.sendToClient,
-      requestId,
-      activeSurfaceId,
-      currentPage,
-      options,
-      displayContent,
-    );
+    return processMessageImpl(this as ProcessConversationContext, {
+      ...options,
+      onEvent: options.onEvent ?? this.sendToClient,
+    });
   }
 
   // ── History ──────────────────────────────────────────────────────
@@ -1363,10 +1344,6 @@ export class Conversation {
 
   // ── Workspace ────────────────────────────────────────────────────
 
-  refreshWorkspaceTopLevelContextIfNeeded(): void {
-    refreshWorkspaceImpl(this);
-  }
-
   markWorkspaceTopLevelDirty(): void {
     this.workspaceTopLevelDirty = true;
   }

package/src/daemon/daemon-skill-host.ts

@@ -25,7 +25,6 @@ import type {
   EventsFacet,
   Filter,
   IdentityFacet,
-  InsertMessageFn,
   LlmProvidersFacet,
   Logger,
   LoggerFacet,
@@ -185,7 +184,7 @@ function buildProvidersFacet(): ProvidersFacet {
 
 function buildMemoryFacet(): MemoryFacet {
   return {
-    addMessage: addMessage as InsertMessageFn,
+    addMessage: addMessage,
     wakeAgentForOpportunity: async (req) => {
       // Contract returns `void`; daemon returns a `WakeResult` that
       // in-process callers don't need through the host surface.
@@ -224,10 +223,7 @@ function buildRegistriesFacet(skillId: string): RegistriesFacet {
     // adapter pairs the provider with the owner derived from the
     // surrounding {@link buildRegistriesFacet} closure.
     registerTools: (provider) =>
-      registerExternalTools(
-        { kind: "skill", id: skillId },
-        provider as never,
-      ),
+      registerExternalTools({ kind: "skill", id: skillId }, provider as never),
     registerSkillRoute: (route: SkillRoute): SkillRouteHandle =>
       registerSkillRoute(route) as unknown as SkillRouteHandle,
     // Namespace hook names by skillId so two skills using the same label

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

@@ -1,3 +1,8 @@
+import {
+  type DiskPressureBlockedCapability,
+  type DiskPressureState,
+  type DiskPressureStatus,
+} from "../api/events/disk-pressure-status-changed.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { cancelBackgroundTools } from "../tools/background-tool-registry.js";
@@ -12,39 +17,26 @@ export const DISK_PRESSURE_THRESHOLD_PERCENT = 95;
 // 95% — otherwise clearing the lock immediately resumes background work,
 // which can refill the disk and re-trip the lock on the next sample.
 export const DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT = 90;
+// Warning-side hysteresis lower bound: once in the warning state, usage must
+// fall below this clear threshold before warning resolves. The deadband between
+// this and the warning threshold stops the in-chat disk-pressure banner from
+// flapping when usage hovers near 80% — without it, a brief dip below 80%
+// clears the warning state, which discards the banner's (state-scoped) dismissal
+// so it re-appears the moment usage ticks back up.
+export const DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT = 77;
 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"
-  | "warning"
-  | "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;
-}
+] as const satisfies readonly DiskPressureBlockedCapability[];
+
+export {
+  type DiskPressureBlockedCapability,
+  type DiskPressureState,
+  type DiskPressureStatus,
+};
 
 export type DiskPressureTransitionResult =
   | { ok: true; status: DiskPressureStatus }
@@ -228,8 +220,22 @@ export function evaluateDiskPressureNow(): DiskPressureStatus {
     ? DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT
     : DISK_PRESSURE_THRESHOLD_PERCENT;
   const isCritical = usagePercent >= criticalThreshold;
-  const isWarning =
-    !isCritical && usagePercent >= DISK_PRESSURE_WARNING_THRESHOLD_PERCENT;
+  // Mirror the critical deadband for the warning band: once in an active
+  // pressure state (warning or critical), hold warning until usage clears the
+  // lower warning-clear threshold. Treating "critical" as active here matters
+  // for a direct step-down: when cleanup frees a lot of space in one sample,
+  // usage can drop straight from a critical lock to e.g. 78%, which is below
+  // the 80% warning trigger but above the 77% clear threshold. Using the full
+  // 80% threshold in that case would report "ok" and discard the warning/
+  // dismissal, reopening the flapping window on the next tick back up. The
+  // deadband must apply consistently whether we arrived in the warning band
+  // from below (rising past 80%) or from above (falling out of critical).
+  const inActivePressureState =
+    state.status.state === "warning" || state.status.state === "critical";
+  const warningThreshold = inActivePressureState
+    ? DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT
+    : DISK_PRESSURE_WARNING_THRESHOLD_PERCENT;
+  const isWarning = !isCritical && usagePercent >= warningThreshold;
   const lastCheckedAt = new Date().toISOString();
 
   if (!isCritical && !isWarning) {