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

package/src/__tests__/conversations-import-system-filter.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Tests that the conversations import route never persists non-renderable
+ * roles. The messages store is UI-facing (`ConversationMessage`), so an
+ * imported export carrying agent-context `system` rows must land only its
+ * `user`/`assistant` turns — the `system` rows are dropped, not persisted.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+mock.module("../memory/indexer.js", () => ({
+  indexMessageNow: async () => {},
+}));
+
+import { getMessages } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations, messages } from "../memory/schema.js";
+import { ROUTES } from "../runtime/routes/conversations-import-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+
+initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+const importHandler = ROUTES.find(
+  (r) => r.operationId === "conversations_import",
+)!.handler;
+
+describe("conversations import system-row filtering", () => {
+  beforeEach(resetTables);
+
+  test("imports renderable turns but drops system rows", async () => {
+    // GIVEN an export whose conversation sandwiches a system row between two
+    // renderable turns (e.g. agent-context scaffolding an export carried)
+    const body = {
+      conversations: [
+        {
+          sourceKey: "src-1",
+          title: "Imported chat",
+          messages: [
+            { role: "user", content: "first visible" },
+            { role: "system", content: "agent-context scaffolding" },
+            { role: "assistant", content: "second visible" },
+          ],
+        },
+      ],
+    };
+
+    // WHEN the conversation is imported
+    const result = (await importHandler({
+      body,
+    } as unknown as RouteHandlerArgs)) as {
+      ok: boolean;
+      imported: number;
+      messages: number;
+    };
+
+    // THEN the import succeeds and only counts the renderable turns
+    expect(result.ok).toBe(true);
+    expect(result.imported).toBe(1);
+    expect(result.messages).toBe(2);
+
+    // AND the persisted rows are exactly the user/assistant turns, never the
+    // system scaffolding
+    const db = getDb();
+    const conv = db.select().from(conversations).all()[0];
+    const rows = getMessages(conv.id);
+    expect(rows.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(
+      db
+        .select()
+        .from(messages)
+        .all()
+        .some((m) => m.role === "system"),
+    ).toBe(false);
+  });
+});

package/src/__tests__/credential-execution-tools.test.ts

@@ -5,7 +5,6 @@ import { makeAuthenticatedRequestTool } from "../tools/credential-execution/make
 import { manageSecureCommandTool } from "../tools/credential-execution/manage-secure-command-tool.js";
 import { runAuthenticatedCommandTool } from "../tools/credential-execution/run-authenticated-command.js";
 import { cesTools, getCesToolsIfEnabled } from "../tools/tool-manifest.js";
-import type { Tool } from "../tools/types.js";
 
 // ---------------------------------------------------------------------------
 // Schema shape tests
@@ -79,7 +78,7 @@ describe("CES tool schema shapes", () => {
 describe("CES tool manifest registration", () => {
   test("cesTools contains exactly three CES tools", () => {
     expect(cesTools).toHaveLength(3);
-    const names = cesTools.map((t: Tool) => t.name);
+    const names = cesTools.map((t) => t.name);
     expect(names).toContain("make_authenticated_request");
     expect(names).toContain("run_authenticated_command");
     expect(names).toContain("manage_secure_command_tool");

package/src/__tests__/credential-security-invariants.test.ts

@@ -171,7 +171,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/handlers/config-telegram.ts", // Telegram bot token management
       "daemon/handlers/config-vercel.ts", // Vercel API token management
       "runtime/routes/integrations/twilio.ts", // Twilio credential management (HTTP control-plane)
-      "acp/prepare-agent-env.ts", // shared helper injects CLAUDE_CODE_OAUTH_TOKEN into claude-agent-acp subprocess env (called by route + skill tool spawn paths)
       "security/token-manager.ts", // OAuth token refresh flow
       "tools/network/script-proxy/session-manager.ts", // proxy credential injection at runtime
       "calls/call-domain.ts", // caller identity resolution (user phone number lookup)

package/src/__tests__/cross-provider-web-search.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type {
   ContentBlock,
@@ -221,6 +221,64 @@ import {
   OpenAIResponsesProvider,
 } from "../providers/openai/client.js";
 
+// ---------------------------------------------------------------------------
+// App-side web_search provider adapters (Brave/Perplexity/Tavily)
+//
+// Exercise the real `web-search.ts` execute path with a mocked config, provider
+// key, and global fetch. The logger is mocked to capture structured warnings so
+// we can assert the `web_search_backend_failure` telemetry (ATL-727).
+// ---------------------------------------------------------------------------
+
+let mockWebSearchProvider: string = "brave";
+let mockProviderKey: string | undefined = "test-key";
+const capturedWarnLogs: Record<string, unknown>[] = [];
+
+const realConfigLoader = await import("../config/loader.js");
+mock.module("../config/loader.js", () => ({
+  ...realConfigLoader,
+  getConfig: () => ({
+    services: { "web-search": { provider: mockWebSearchProvider } },
+  }),
+}));
+
+const realSecureKeys = await import("../security/secure-keys.js");
+mock.module("../security/secure-keys.js", () => ({
+  ...realSecureKeys,
+  getProviderKeyAsync: async () => mockProviderKey,
+}));
+
+const realLogger = await import("../util/logger.js");
+mock.module("../util/logger.js", () => ({
+  ...realLogger,
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: (_target, prop) => {
+        if (prop === "warn") {
+          return (obj: Record<string, unknown>) => {
+            capturedWarnLogs.push(obj);
+          };
+        }
+        return () => {};
+      },
+    }),
+}));
+
+const { webSearchTool } = await import("../tools/network/web-search.js");
+const { WEB_SEARCH_BACKEND_FAILURE_MESSAGE } = await import(
+  "../tools/network/web-search-error.js"
+);
+
+function executeWebSearch(input: Record<string, unknown>) {
+  return webSearchTool.execute(input, {} as never);
+}
+
+function executeWebSearchWithSignal(
+  input: Record<string, unknown>,
+  signal: AbortSignal,
+) {
+  return webSearchTool.execute(input, { signal } as never);
+}
+
 // ---------------------------------------------------------------------------
 // OpenAI Responses API provider tests
 // ---------------------------------------------------------------------------
@@ -366,7 +424,9 @@ describe("Cross-Provider Web Search — OpenAI (Responses API, native mode)", ()
       },
     ];
 
-    await provider.sendMessage([userMsg("Search for something")], tools);
+    await provider.sendMessage([userMsg("Search for something")], {
+      tools,
+    });
 
     const sentTools = lastOpenAIResponsesParams!.tools as Array<
       Record<string, unknown>
@@ -494,7 +554,9 @@ describe("Cross-Provider Web Search — Fireworks", () => {
       "accounts/fireworks/models/kimi-k2p6",
     );
 
-    await provider.sendMessage([userMsg("Search for something")], sampleTools);
+    await provider.sendMessage([userMsg("Search for something")], {
+      tools: sampleTools,
+    });
 
     const tools = lastOpenAIChatParams!.tools as Array<{
       type: string;
@@ -600,3 +662,158 @@ describe("Cross-Provider Web Search — Gemini", () => {
     expect(functionCallParts).toHaveLength(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// App-side provider backend-failure normalization (ATL-727)
+// ---------------------------------------------------------------------------
+
+describe("Cross-Provider Web Search — app-side backend failure normalization", () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    mockWebSearchProvider = "brave";
+    mockProviderKey = "test-key";
+    capturedWarnLogs.length = 0;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function backendFailureLog() {
+    return capturedWarnLogs.find(
+      (entry) => entry.event === "web_search_backend_failure",
+    );
+  }
+
+  test("503 from provider yields friendly recoverable copy in content + errorMessage, logs raw 503, no body leak", async () => {
+    const rawBody = '{"error":"upstream exploded","trace":"do-not-leak"}';
+    globalThis.fetch = (async () =>
+      new Response(rawBody, { status: 503 })) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "needle in a haystack" });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    const meta = result.activityMetadata?.webSearch;
+    expect(meta?.errorMessage).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    expect(meta?.results).toEqual([]);
+    expect(meta?.resultCount).toBe(0);
+
+    const logEntry = backendFailureLog();
+    expect(logEntry).toBeDefined();
+    expect(logEntry!.provider).toBe("brave");
+    expect(logEntry!.errorCategory).toBe("backend_unavailable");
+    expect(logEntry!.fallbackShown).toBe(true);
+    expect(logEntry!.queryLength).toBe("needle in a haystack".length);
+    expect(String(logEntry!.rawDetail)).toContain("503");
+    // Provider diagnostic body is preserved in internal telemetry rawDetail.
+    expect(String(logEntry!.rawDetail)).toContain("upstream exploded");
+    expect(String(logEntry!.rawDetail)).toContain("do-not-leak");
+
+    // Raw provider body must never reach user-facing fields.
+    expect(result.content).not.toContain("upstream exploded");
+    expect(result.content).not.toContain("do-not-leak");
+    expect(meta?.errorMessage).not.toContain("upstream exploded");
+    expect(meta?.errorMessage).not.toContain("do-not-leak");
+  });
+
+  test("thrown network error yields the same friendly backend result", async () => {
+    globalThis.fetch = (async () => {
+      throw new TypeError("fetch failed");
+    }) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "offline" });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    expect(result.activityMetadata?.webSearch?.errorMessage).toBe(
+      WEB_SEARCH_BACKEND_FAILURE_MESSAGE,
+    );
+    const logEntry = backendFailureLog();
+    expect(logEntry).toBeDefined();
+    expect(logEntry!.errorCategory).toBe("backend_unavailable");
+    expect(result.content).not.toContain("fetch failed");
+  });
+
+  test("401 invalid-key preserves the specific message, not the backend copy", async () => {
+    globalThis.fetch = (async () =>
+      new Response("Unauthorized", { status: 401 })) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "bad key" });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Invalid or expired Brave Search API key");
+    expect(result.content).not.toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    expect(result.activityMetadata?.webSearch?.errorMessage).not.toBe(
+      WEB_SEARCH_BACKEND_FAILURE_MESSAGE,
+    );
+    expect(backendFailureLog()).toBeUndefined();
+  });
+
+  test("HTTP 200 with zero results stays a success (unchanged)", async () => {
+    globalThis.fetch = (async () =>
+      new Response(JSON.stringify({ web: { results: [] } }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      })) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "no hits" });
+
+    expect(result.isError).toBe(false);
+    expect(result.activityMetadata?.webSearch?.errorMessage).toBeUndefined();
+    expect(result.content).toContain("No results found");
+    expect(backendFailureLog()).toBeUndefined();
+  });
+
+  test("post-retry 429 yields the friendly recoverable copy and preserves body in rawDetail", async () => {
+    const rawBody = '{"error":"quota burned","retryHint":"do-not-leak-429"}';
+    globalThis.fetch = (async () =>
+      new Response(rawBody, {
+        status: 429,
+        headers: { "retry-after": "0" },
+      })) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "rate limited" });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    const meta = result.activityMetadata?.webSearch;
+    expect(meta?.errorMessage).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    const logEntry = backendFailureLog();
+    expect(logEntry).toBeDefined();
+    expect(logEntry!.errorCategory).toBe("rate_limited");
+    expect(String(logEntry!.rawDetail)).toContain("429");
+    // Provider diagnostic body is preserved in internal telemetry rawDetail.
+    expect(String(logEntry!.rawDetail)).toContain("quota burned");
+    expect(String(logEntry!.rawDetail)).toContain("do-not-leak-429");
+
+    // Raw provider body must never reach user-facing fields.
+    expect(result.content).not.toContain("quota burned");
+    expect(result.content).not.toContain("do-not-leak-429");
+    expect(meta?.errorMessage).not.toContain("quota burned");
+    expect(meta?.errorMessage).not.toContain("do-not-leak-429");
+  });
+
+  test("caller abort re-throws instead of producing a backend failure (no telemetry)", async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    // A caller-aborted request surfaces an AbortError from fetch.
+    globalThis.fetch = (async () => {
+      const abortError = new Error("The operation was aborted");
+      abortError.name = "AbortError";
+      throw abortError;
+    }) as unknown as typeof fetch;
+
+    // The cancellation must re-throw so the executor's abort handling takes
+    // over — NOT resolve to the friendly backend-failure result.
+    await expect(
+      executeWebSearchWithSignal({ query: "cancel me" }, controller.signal),
+    ).rejects.toThrow();
+
+    // No spurious backend-failure telemetry for a user/external cancellation.
+    expect(backendFailureLog()).toBeUndefined();
+  });
+});

package/src/__tests__/cu-unified-flow.test.ts

@@ -438,7 +438,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("multiple clients support host_cu");
+      expect(result.content).toContain("Multiple host_cu clients");
       expect(result.content).toContain("target_client_id");
       // No message should have been dispatched
       expect(sentMessages).toHaveLength(0);
@@ -705,6 +705,31 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
       await resultPromise;
     });
+
+    test("rejects untargeted CU dispatch when only another actor has a capable client", async () => {
+      sentMessages.length = 0;
+      mockHasClient = true;
+      mockCuClients = [
+        {
+          clientId: "cu-other",
+          capabilities: ["host_cu"],
+          actorPrincipalId: "user-other",
+        },
+      ];
+      proxy = new HostCuProxy();
+      const ctx = buildMockContext(proxy, DEFAULT_PRINCIPAL);
+
+      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("current actor");
+      // No step burned, no dispatch.
+      expect(proxy.stepCount).toBe(0);
+      expect(sentMessages).toHaveLength(0);
+    });
   });
 
   describe("step limit enforcement through resolver", () => {

package/src/__tests__/db-acp-history.test.ts

@@ -5,6 +5,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { migrate230AcpSessionHistory } from "../memory/migrations/230-acp-session-history.js";
+import { migrateAcpSessionHistoryCwd } from "../memory/migrations/272-acp-session-history-cwd.js";
 import * as schema from "../memory/schema.js";
 
 function createTestDb() {
@@ -282,3 +283,103 @@ describe("acp_session_history migration", () => {
     expect(row?.id).toBe("history-rerun");
   });
 });
+
+describe("acp_session_history cwd migration (272)", () => {
+  function readColumns(raw: Database): Map<string, ColumnRow> {
+    const columns = raw
+      .query(`PRAGMA table_info(acp_session_history)`)
+      .all() as ColumnRow[];
+    return new Map(columns.map((c) => [c.name, c]));
+  }
+
+  test("adds a nullable cwd TEXT column to an upgraded table", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+    expect(readColumns(raw).has("cwd")).toBe(false);
+
+    migrateAcpSessionHistoryCwd(db);
+
+    const cwd = readColumns(raw).get("cwd");
+    expect(cwd).toBeDefined();
+    expect(cwd?.type).toBe("TEXT");
+    expect(cwd?.notnull).toBe(0);
+  });
+
+  test("re-running is a no-op, including with a cleared checkpoint", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+    migrateAcpSessionHistoryCwd(db);
+
+    // Second run short-circuits on the completed checkpoint.
+    expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
+
+    // Even with the checkpoint cleared (simulating crash recovery), the
+    // column-existence guard makes the ALTER a no-op.
+    raw
+      .query(`DELETE FROM memory_checkpoints WHERE key = ?`)
+      .run("migration_acp_session_history_cwd_v1");
+    expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
+
+    const columns = raw
+      .query(`PRAGMA table_info(acp_session_history)`)
+      .all() as ColumnRow[];
+    expect(columns.filter((c) => c.name === "cwd")).toHaveLength(1);
+  });
+
+  test("legacy rows read back with cwd null; new rows round-trip cwd", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+
+    // Legacy row inserted before the cwd column existed.
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO acp_session_history (
+          id, agent_id, acp_session_id, parent_conversation_id,
+          started_at, status
+        ) VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run("legacy-1", "agent-old", "acp-old", "conv-old", 100, "completed");
+
+    migrateAcpSessionHistoryCwd(db);
+
+    const legacy = raw
+      .query(`SELECT cwd FROM acp_session_history WHERE id = 'legacy-1'`)
+      .get() as { cwd: string | null } | null;
+    expect(legacy?.cwd).toBeNull();
+
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO acp_session_history (
+          id, agent_id, acp_session_id, parent_conversation_id,
+          started_at, status, cwd
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run(
+        "new-1",
+        "agent-new",
+        "acp-new",
+        "conv-new",
+        200,
+        "completed",
+        "/Users/me/project",
+      );
+
+    const fresh = raw
+      .query(`SELECT cwd FROM acp_session_history WHERE id = 'new-1'`)
+      .get() as { cwd: string | null } | null;
+    expect(fresh?.cwd).toBe("/Users/me/project");
+  });
+});

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, test } from "bun:test";
 import { eq } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
+import { migrateScheduleSourceConversation } from "../memory/migrations/270-schedule-source-conversation.js";
 import * as schema from "../memory/schema.js";
 import { scheduleJobs } from "../memory/schema.js";
 
@@ -38,6 +39,7 @@ describe("schedule_syntax column migration", () => {
         retry_count INTEGER NOT NULL DEFAULT 0,
         max_retries INTEGER NOT NULL DEFAULT 3,
         retry_backoff_ms INTEGER NOT NULL DEFAULT 60000,
+        created_from_conversation_id TEXT,
         created_by TEXT NOT NULL,
         mode TEXT NOT NULL DEFAULT 'execute',
         routing_intent TEXT NOT NULL DEFAULT 'all_channels',
@@ -47,6 +49,7 @@ describe("schedule_syntax column migration", () => {
         reuse_conversation INTEGER NOT NULL DEFAULT 0,
         script TEXT,
         wake_conversation_id TEXT,
+        timeout_ms INTEGER,
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
       )
@@ -128,6 +131,12 @@ describe("schedule_syntax column migration", () => {
     } catch {
       /* already exists */
     }
+    try {
+      raw.exec(`ALTER TABLE cron_jobs ADD COLUMN timeout_ms INTEGER`);
+    } catch {
+      /* already exists */
+    }
+    migrateScheduleSourceConversation(db);
 
     const row = db
       .select()
@@ -186,6 +195,13 @@ describe("schedule_syntax column migration", () => {
     } catch {
       /* ok */
     }
+    try {
+      raw.exec(`ALTER TABLE cron_jobs ADD COLUMN timeout_ms INTEGER`);
+    } catch {
+      /* ok */
+    }
+    migrateScheduleSourceConversation(db);
+    migrateScheduleSourceConversation(db);
 
     const now = Date.now();
     raw.exec(

package/src/__tests__/disk-pressure-guard.test.ts

@@ -40,6 +40,8 @@ const {
   DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT,
   DISK_PRESSURE_OVERRIDE_CONFIRMATION,
   DISK_PRESSURE_THRESHOLD_PERCENT,
+  DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT,
+  DISK_PRESSURE_WARNING_THRESHOLD_PERCENT,
   __getDiskPressureGuardTimerForTests,
   __resetDiskPressureGuardForTests,
   acknowledgeDiskPressureLock,
@@ -276,4 +278,68 @@ describe("disk pressure guard", () => {
     stopDiskPressureGuard();
     expect(__getDiskPressureGuardTimerForTests()).toBeNull();
   });
+
+  test("does not enter warning until usage reaches the warning threshold", () => {
+    // Below 80% and never previously in a pressure state.
+    setDiskUsage(DISK_PRESSURE_WARNING_THRESHOLD_PERCENT - 2);
+
+    const status = evaluateDiskPressureNow();
+
+    expect(status.state).toBe("ok");
+  });
+
+  test("holds the warning state across a dip within the warning clear deadband", () => {
+    setDiskUsage(DISK_PRESSURE_WARNING_THRESHOLD_PERCENT + 2);
+    expect(evaluateDiskPressureNow().state).toBe("warning");
+
+    // Below the 80% warning threshold but at/above the 77% clear threshold.
+    setDiskUsage(DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT + 1);
+    expect(evaluateDiskPressureNow().state).toBe("warning");
+  });
+
+  test("clears the warning state once usage falls below the warning clear threshold", () => {
+    setDiskUsage(DISK_PRESSURE_WARNING_THRESHOLD_PERCENT + 2);
+    expect(evaluateDiskPressureNow().state).toBe("warning");
+
+    setDiskUsage(DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT - 1);
+    expect(evaluateDiskPressureNow().state).toBe("ok");
+  });
+
+  test("steps a critical lock down into a held warning state", () => {
+    setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT + 1);
+    expect(evaluateDiskPressureNow().state).toBe("critical");
+
+    // Below the 90% critical clear but above the 80% warning threshold.
+    setDiskUsage(DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT - 2);
+    const stepped = evaluateDiskPressureNow();
+    expect(stepped.state).toBe("warning");
+    expect(stepped.locked).toBe(false);
+
+    // Now within the warning clear deadband — warning must hold, not flap to ok.
+    setDiskUsage(DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT + 1);
+    expect(evaluateDiskPressureNow().state).toBe("warning");
+  });
+
+  test("holds warning when a critical lock drops straight into the warning deadband", () => {
+    setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT + 1);
+    expect(evaluateDiskPressureNow().state).toBe("critical");
+
+    // A single large cleanup drops usage directly from critical to below the
+    // 80% warning threshold but still at/above the 77% clear threshold. The
+    // deadband must apply when stepping down out of critical too, so this holds
+    // as warning rather than flapping to ok (which would reopen the flap window).
+    setDiskUsage(DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT + 1);
+    const stepped = evaluateDiskPressureNow();
+    expect(stepped.state).toBe("warning");
+    expect(stepped.locked).toBe(false);
+  });
+
+  test("clears straight to ok when a critical lock drops below the warning clear threshold", () => {
+    setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT + 1);
+    expect(evaluateDiskPressureNow().state).toBe("critical");
+
+    // A drop below even the warning-clear threshold is a genuine recovery.
+    setDiskUsage(DISK_PRESSURE_WARNING_CLEAR_THRESHOLD_PERCENT - 1);
+    expect(evaluateDiskPressureNow().state).toBe("ok");
+  });
 });

package/src/__tests__/disk-pressure-routes.test.ts

@@ -49,10 +49,17 @@ const {
   evaluateDiskPressureNow,
 } = await import("../daemon/disk-pressure-guard.js");
 const { assistantEventHub } = await import("../runtime/assistant-event-hub.js");
-const { getPolicy } = await import("../runtime/auth/route-policy.js");
 const { RouteError } = await import("../runtime/routes/errors.js");
 const { ROUTES } = await import("../runtime/routes/disk-pressure-routes.js");
 
+/** Look up a route's policy by endpoint+method on the module's ROUTES. */
+function routePolicy(endpoint: string, method?: string) {
+  const route = ROUTES.find(
+    (r) => r.endpoint === endpoint && (!method || r.method === method),
+  );
+  return route?.policy ?? null;
+}
+
 type DiskPressureRouteResult = {
   status: {
     enabled: boolean;
@@ -152,7 +159,7 @@ describe("disk pressure routes", () => {
           (route) => route.endpoint === endpoint && route.method === method,
         ),
       ).toBe(true);
-      expect(getPolicy(endpoint)).toBeDefined();
+      expect(routePolicy(endpoint)).not.toBeNull();
     }
   });