@mycadet/assistant 0.12.7-dev.202610111049.d2b52a8 → 0.12.8

package/src/api/events/cloud-disconnected.ts

@@ -1,5 +1,5 @@
 /**
- * `platform_disconnected` SSE event.
+ * `cloud_disconnected` SSE event.
  *
  * Emitted by the cloud-disconnect route after stored platform
  * credentials are deleted, notifying connected clients that the cloud
@@ -13,7 +13,7 @@
 import { z } from "zod";
 
 export const CloudDisconnectedEventSchema = z.object({
-  type: z.literal("platform_disconnected"),
+  type: z.literal("cloud_disconnected"),
 });
 
 export type CloudDisconnectedEvent = z.infer<

package/src/config/schemas/cloud.ts

@@ -33,7 +33,8 @@ function timezoneConfigField(path: string) {
         return z.NEVER;
       }
       return canonical;
-    });
+    })
+    .pipe(z.string());
 }
 
 export const CloudConfigSchema = z

package/src/config/schemas/host-browser.ts

@@ -61,6 +61,7 @@ const HostBrowserCdpInspectConfigSchema = z
       .string({ error: "hostBrowser.cdpInspect.host must be a string" })
       .transform((v) => v || "localhost")
       .default("localhost")
+      .pipe(z.string())
       .describe(
         "Host name or IP address where the host Chrome instance exposes its remote debugging endpoint.",
       ),

package/src/config/schemas/ingress.ts

@@ -94,14 +94,6 @@ const IngressBaseSchema = z
     rateLimit: IngressRateLimitConfigSchema.default(
       IngressRateLimitConfigSchema.parse({}),
     ),
-    shutdownDrainMs: z
-      .number({ error: "ingress.shutdownDrainMs must be a number" })
-      .int("ingress.shutdownDrainMs must be an integer")
-      .nonnegative("ingress.shutdownDrainMs must be a non-negative integer")
-      .default(5_000)
-      .describe(
-        "Time in milliseconds to drain in-flight requests during graceful shutdown",
-      ),
   })
   .describe(
     "Ingress HTTP server configuration — handles incoming webhooks, API requests, and channel events",
@@ -109,10 +101,7 @@ const IngressBaseSchema = z
 
 export const IngressConfigSchema = IngressBaseSchema.default(
   IngressBaseSchema.parse({}),
-).transform((val) => ({
-  ...val,
-  enabled: val.enabled,
-}));
+);
 
 export type IngressWebhookConfig = z.infer<typeof IngressWebhookConfigSchema>;
 export type IngressRateLimitConfig = z.infer<

package/src/config/schemas/llm.ts

@@ -733,7 +733,16 @@ export const ProfileEntry = LLMConfigFragment.extend({
    * not supported.
    */
   fallbackProfile: z.string().min(1).optional().meta({ readOnly: true }),
-});
+  /**
+   * Wire-only capability flags: stamped onto config-read responses by
+   * `enrichProfilesForWire` and stripped from incoming writes by
+   * `stripWireOnlyProfileKeys` (conversation-query-routes), so they never
+   * persist. Declared here so the wire contract (AssistantConfig → SDK
+   * types) describes the enriched profile shape clients consume.
+   */
+  supportsVision: z.boolean().optional(),
+  invariant: z.boolean().optional(),
+}).meta({ id: "ProfileEntry" });
 export type ProfileEntry = z.infer<typeof ProfileEntry>;
 
 /**

package/src/config/schemas/memory-lifecycle.ts

@@ -41,6 +41,14 @@ const MemoryJobsConfigInputSchema = z.object({
     ),
 });
 
+const MemoryJobsConfigOutputSchema = z.object({
+  workerConcurrency: positiveInt("workerConcurrency"),
+  stalledJobTimeoutMs: positiveInt("stalledJobTimeoutMs"),
+  slowLlmConcurrency: positiveInt("slowLlmConcurrency"),
+  fastConcurrency: positiveInt("fastConcurrency"),
+  embedConcurrency: positiveInt("embedConcurrency"),
+});
+
 export const MemoryJobsConfigSchema = MemoryJobsConfigInputSchema.transform(
   (input) => {
     // When `workerConcurrency` is explicitly set but lane caps are not,
@@ -76,7 +84,9 @@ export const MemoryJobsConfigSchema = MemoryJobsConfigInputSchema.transform(
       embedConcurrency,
     };
   },
-).describe("Memory background job processing configuration");
+)
+  .pipe(MemoryJobsConfigOutputSchema)
+  .describe("Memory background job processing configuration");
 
 export const MemoryRetentionConfigSchema = z
   .object({

package/src/config/schemas/tts.ts

@@ -52,6 +52,7 @@ function languageVoicesSchema(providerId: string, valuesDescription: string) {
       }
       return Object.fromEntries(normalized);
     })
+    .pipe(z.record(z.string(), z.string()))
     .optional()
     .describe(
       "Per-language voice overrides for live voice. Keys are normalized on " +
@@ -70,6 +71,7 @@ export const TtsElevenLabsProviderConfigSchema = z
       })
       .transform((v) => v || DEFAULT_ELEVENLABS_VOICE_ID)
       .default(DEFAULT_ELEVENLABS_VOICE_ID)
+      .pipe(z.string())
       .describe("ElevenLabs voice ID for text-to-speech"),
     voiceModelId: z
       .string({
@@ -194,6 +196,7 @@ export const TtsDeepgramProviderConfigSchema = z
       })
       .transform((v) => v || "aura-asteria-en")
       .default("aura-asteria-en")
+      .pipe(z.string())
       .describe("Deepgram TTS model identifier"),
     format: z
       .enum(["mp3", "wav", "opus"], {
@@ -221,6 +224,7 @@ export const TtsXaiProviderConfigSchema = z
       })
       .transform((v) => v || "eve")
       .default("eve")
+      .pipe(z.string())
       .describe(
         "xAI voice ID — one of: eve, ara, rex, sal, leo (case-insensitive)",
       ),
@@ -230,6 +234,7 @@ export const TtsXaiProviderConfigSchema = z
       })
       .transform((v) => v || "auto")
       .default("auto")
+      .pipe(z.string())
       .describe(
         "BCP-47 language code (e.g. 'en-US') or 'auto' for auto-detection",
       ),

package/src/credential-execution/prompted-credential.ts

@@ -18,10 +18,7 @@ import {
   assertAcpCredentialFormat,
 } from "../acp/acp-credentials.js";
 import { getConfig } from "../config/loader.js";
-import {
-  isNonSecretPlatformField,
-  scrubStoredCredentialFromTranscripts,
-} from "../daemon/credential-transcript-scrub.js";
+import { scrubStoredCredentialFromTranscripts } from "../daemon/credential-transcript-scrub.js";
 import {
   setSlackChannelConfig,
   type SlackChannelConfigResult,
@@ -209,20 +206,11 @@ export async function persistPromptedCredential(args: {
   // (the 06-credential-security rail promises that pasted message is
   // scrubbed after storage). Run the scrub right after the store succeeds,
   // best-effort and invisible to the caller, mirroring credentials_set.
-  if (!isNonSecretPlatformField(service, field)) {
-    try {
-      const scrubbed = await scrubStoredCredentialFromTranscripts(value);
-      log.info(
-        { service, field, ...scrubbed },
-        "Prompted credential stored; scrubbed value from recent transcripts",
-      );
-    } catch (err) {
-      log.warn(
-        { service, field, err },
-        "Prompted credential stored, but transcript scrub failed",
-      );
-    }
-  }
+  const scrubbed = await scrubStoredCredentialFromTranscripts(value);
+  log.info(
+    { service, field, ...scrubbed },
+    "Prompted credential stored; scrubbed value from recent transcripts",
+  );
 
   try {
     upsertCredentialMetadata(service, field, {

package/src/credential-health/credential-health-service.ts

@@ -36,10 +36,7 @@ import {
 } from "../oauth/oauth-store.js";
 import { missingScopesForStoredToken } from "../oauth/scope-utils.js";
 import { credentialKey } from "../security/credential-key.js";
-import {
-  getSecureKeyAsync,
-  getSecureKeyResultAsync,
-} from "../security/secure-keys.js";
+import { getSecureKeyResultAsync } from "../security/secure-keys.js";
 import {
   TokenExpiredError,
   withValidToken,
@@ -636,13 +633,12 @@ const ASSISTANT_API_KEY_CONNECTION_ID = "cadet:assistant_api_key";
  * observed here and acted on by a client.
  *
  * Statuses map onto the shared vocabulary:
- *   - `missing_token`: no key is stored, so managed inference cannot run.
  *   - `revoked`: the cloud settled that the stored key is not accepted.
  *   - `unreachable`: the credential store or the cloud did not answer, so
  *     health is unknown. The heartbeat drops these before notifying, which is
  *     what keeps a transient outage from raising a credential alert.
  *
- * `canAutoRecover` is true for both failure statuses: recovery needs no
+ * `canAutoRecover` is true for the revoked status: recovery needs no
  * re-authorization from the user, only a signed-in client to rotate the key.
  */
 export async function checkAssistantApiKey(): Promise<CredentialHealthResult | null> {
@@ -672,21 +668,10 @@ export async function checkAssistantApiKey(): Promise<CredentialHealthResult | n
 
   if (stored.value == null) {
     // A workspace that was never connected to the cloud has no managed
-    // credential and is not unhealthy. Only an install that already carries
-    // the rest of a cloud identity is missing something.
-    const assistantId = await getSecureKeyAsync(
-      credentialKey("cadet", "platform_assistant_id"),
-    );
-    if (!assistantId) {
-      return null;
-    }
-    return {
-      ...base,
-      status: "missing_token",
-      details:
-        "No Cadet Cloud credentials are stored yet. Log in to Cadet Cloud to set them up.",
-      canAutoRecover: true,
-    };
+    // credential and is not unhealthy. The identity ids resolve from the
+    // api key via the validate endpoint, so a missing key means nothing is
+    // bound — there is nothing to check.
+    return null;
   }
 
   const { CadetCloudClient } = await import("../cloud/client.js");

package/src/daemon/credential-transcript-scrub.ts

@@ -93,44 +93,36 @@ export async function scrubStoredCredentialFromTranscripts(
     dbMessagesScrubbed: 0,
     residentMessagesScrubbed: 0,
   };
-  if (value.trim().length < MIN_SCRUB_VALUE_LENGTH) {
-    return result;
-  }
-  const targets = buildSearchTargets(value);
   try {
-    result.dbMessagesScrubbed = sweepDbMessages(targets);
-  } catch (err) {
-    log.warn(
-      { err, valueLength: value.length },
-      "Credential transcript DB sweep failed; continuing with in-memory sweep",
-    );
-  }
-  try {
-    result.residentMessagesScrubbed = sweepResidentConversations(targets);
+    if (value.trim().length < MIN_SCRUB_VALUE_LENGTH) {
+      return result;
+    }
+    const targets = buildSearchTargets(value);
+    try {
+      result.dbMessagesScrubbed = sweepDbMessages(targets);
+    } catch (err) {
+      log.warn(
+        { err, valueLength: value.length },
+        "Credential transcript DB sweep failed; continuing with in-memory sweep",
+      );
+    }
+    try {
+      result.residentMessagesScrubbed = sweepResidentConversations(targets);
+    } catch (err) {
+      log.warn(
+        { err, valueLength: value.length },
+        "Credential transcript in-memory sweep failed",
+      );
+    }
   } catch (err) {
     log.warn(
       { err, valueLength: value.length },
-      "Credential transcript in-memory sweep failed",
+      "Credential transcript scrub failed",
     );
   }
   return result;
 }
 
-/**
- * The Cadet Cloud identity ids and base URL are stored through the
- * credential routes but are not secrets — they are UUIDs/URLs that
- * legitimately appear in conversation text, so scrubbing them would redact
- * benign transcript content. Both credential write paths
- * (`credentials_set` and the `/v1/secrets` credential branch) consult this
- * one exemption so they cannot drift.
- */
-export function isNonSecretPlatformField(
-  service: string,
-  field: string,
-): boolean {
-  return service === "cadet" && field === "platform_assistant_id";
-}
-
 /**
  * Every transcript encoding of the value ({@link credentialValueEncodings}:
  * raw plus JSON-escaped — tool_use inputs are stored as JSON, and string

package/src/ipc/gateway-client.test.ts

@@ -8,11 +8,7 @@
  */
 import { afterEach, describe, expect, test } from "bun:test";
 
-import {
-  getMockPersistentCallCount,
-  mockGatewayIpc,
-  resetMockGatewayIpc,
-} from "../__tests__/mock-gateway-ipc.js";
+import { mockIpc } from "../__tests__/requests-mock.js";
 import { ServiceUnavailableError } from "../runtime/routes/errors.js";
 import {
   ipcCall,
@@ -25,7 +21,6 @@ import {
 
 afterEach(() => {
   resetPersistentClient();
-  resetMockGatewayIpc();
 });
 
 // ---------------------------------------------------------------------------
@@ -34,22 +29,24 @@ afterEach(() => {
 
 describe("ipcCall", () => {
   test("delegates to package ipcCall and returns result", async () => {
-    mockGatewayIpc(null, {
-      results: { test_method: { key: "value" } },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ test_method: { key: "value" } });
 
     const result = await ipcCall("test_method");
     expect(result).toEqual({ key: "value" });
   });
 
   test("returns undefined when mock simulates error", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     const result = await ipcCall("test_method");
     expect(result).toBeUndefined();
   });
 
   test("returns undefined for unconfigured methods", async () => {
+    await mockIpc("gateway");
+
     const result = await ipcCall("unconfigured_method");
     expect(result).toBeUndefined();
   });
@@ -61,16 +58,16 @@ describe("ipcCall", () => {
 
 describe("ipcCallPersistent", () => {
   test("returns result from persistent client", async () => {
-    mockGatewayIpc(null, {
-      results: { persistent_test: "persistent-result" },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ persistent_test: "persistent-result" });
 
     const result = await ipcCallPersistent("persistent_test");
     expect(result).toBe("persistent-result");
   });
 
   test("maps a missing gateway socket to ServiceUnavailableError", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     await expect(ipcCallPersistent("any_method")).rejects.toBeInstanceOf(
       ServiceUnavailableError,
@@ -92,21 +89,23 @@ describe("ipcCallPersistent", () => {
 
 describe("ipcGetFeatureFlags", () => {
   test("parses boolean flag values from IPC response", async () => {
-    mockGatewayIpc({ "flag-a": true, "flag-b": false });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({
+      get_feature_flags: { "flag-a": true, "flag-b": false },
+    });
 
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({ "flag-a": true, "flag-b": false });
   });
 
   test("accepts boolean and string values, filters other types from response", async () => {
-    mockGatewayIpc(null, {
-      results: {
-        get_feature_flags: {
-          valid: true,
-          number: 42,
-          string: "yes",
-          nested: { deep: true },
-        },
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({
+      get_feature_flags: {
+        valid: true,
+        number: 42,
+        string: "yes",
+        nested: { deep: true },
       },
     });
 
@@ -115,25 +114,26 @@ describe("ipcGetFeatureFlags", () => {
   });
 
   test("returns empty record when IPC returns undefined", async () => {
-    // Explicitly suppress the mock's default `get_feature_flags` sentinel
-    // (which exists to short-circuit `initFeatureFlagOverrides()`'s retry
-    // loop) so this test exercises the underlying-undefined path.
-    mockGatewayIpc(null, { results: { get_feature_flags: undefined } });
+    // Explicitly suppress the transport's default `get_feature_flags`
+    // sentinel (which exists to short-circuit `initFeatureFlagOverrides()`'s
+    // retry loop) so this test exercises the underlying-undefined path.
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ get_feature_flags: undefined });
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({});
   });
 
   test("returns empty record when IPC returns array", async () => {
-    mockGatewayIpc(null, {
-      results: { get_feature_flags: [true, false] },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ get_feature_flags: [true, false] });
 
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({});
   });
 
   test("returns empty record on error", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({});
@@ -142,12 +142,11 @@ describe("ipcGetFeatureFlags", () => {
 
 describe("ipcGetTunnelStatus", () => {
   test("parses the shared Tunnel status response", async () => {
-    mockGatewayIpc(null, {
-      results: {
-        get_tunnel_status: {
-          connected: true,
-          publicUrl: "https://example.test",
-        },
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({
+      get_tunnel_status: {
+        connected: true,
+        publicUrl: "https://example.test",
       },
     });
 
@@ -158,10 +157,9 @@ describe("ipcGetTunnelStatus", () => {
   });
 
   test("keeps connected status when publicUrl is malformed", async () => {
-    mockGatewayIpc(null, {
-      results: {
-        get_tunnel_status: { connected: false, publicUrl: 42 },
-      },
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({
+      get_tunnel_status: { connected: false, publicUrl: 42 },
     });
 
     expect(await ipcGetTunnelStatus()).toEqual({
@@ -171,9 +169,8 @@ describe("ipcGetTunnelStatus", () => {
   });
 
   test("returns null when connected is missing or malformed", async () => {
-    mockGatewayIpc(null, {
-      results: { get_tunnel_status: { connected: "yes" } },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ get_tunnel_status: { connected: "yes" } });
 
     expect(await ipcGetTunnelStatus()).toBeNull();
   });
@@ -193,38 +190,37 @@ describe("ipcClassifyRisk retry", () => {
   const emptyParams = {} as unknown as Parameters<typeof ipcClassifyRisk>[0];
 
   test("retries a transient failure and then succeeds", async () => {
-    mockGatewayIpc(null, {
-      failFirstN: 1,
-      results: { classify_risk: CLASSIFY_OK },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.failFirstN(1);
+    gateway.setDefaults({ classify_risk: CLASSIFY_OK });
 
     const result = await ipcClassifyRisk(emptyParams);
     expect(result?.risk).toBe("low");
-    expect(getMockPersistentCallCount("classify_risk")).toBe(2);
+    expect(gateway.persistentCallCount("classify_risk")).toBe(2);
   });
 
   test("returns undefined after exhausting retries (3 attempts)", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     const result = await ipcClassifyRisk(emptyParams);
     expect(result).toBeUndefined();
-    expect(getMockPersistentCallCount("classify_risk")).toBe(3);
+    expect(gateway.persistentCallCount("classify_risk")).toBe(3);
   });
 
   test("does NOT retry a structured IpcCallError (fails after 1 attempt)", async () => {
-    mockGatewayIpc(null, {
-      failFirstN: 3,
-      ipcCallError: true,
-      results: { classify_risk: CLASSIFY_OK },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.failFirstN(3, { ipcCallError: true });
+    gateway.setDefaults({ classify_risk: CLASSIFY_OK });
 
     const result = await ipcClassifyRisk(emptyParams);
     expect(result).toBeUndefined();
-    expect(getMockPersistentCallCount("classify_risk")).toBe(1);
+    expect(gateway.persistentCallCount("classify_risk")).toBe(1);
   });
 
   test("stops retrying once the signal is aborted", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
     const controller = new AbortController();
     controller.abort();
 
@@ -232,6 +228,6 @@ describe("ipcClassifyRisk retry", () => {
     expect(result).toBeUndefined();
     // An already-aborted signal short-circuits the retry loop after the first
     // failed attempt rather than exhausting all three.
-    expect(getMockPersistentCallCount("classify_risk")).toBe(1);
+    expect(gateway.persistentCallCount("classify_risk")).toBe(1);
   });
 });

package/src/persistence/compaction-log-store-clickhouse.ts

@@ -408,7 +408,7 @@ export class ClickHouseCompactionLogStore {
     const val = await this.resolveAssistantId();
     if (!val) {
       throw new Error(
-        "cadet:platform_assistant_id credential is required when compactionLogs.destination=clickhouse",
+        "Cadet Cloud assistant id is required when compactionLogs.destination=clickhouse",
       );
     }
     this.cachedAssistantId = val;

package/src/persistence/llm-request-log-sink-clickhouse.ts

@@ -258,7 +258,7 @@ export class ClickHouseLlmRequestLogSink implements LlmRequestLogWriter {
     const val = await this.resolveAssistantId();
     if (!val) {
       throw new Error(
-        "cadet:platform_assistant_id credential is required when readSource=clickhouse",
+        "Cadet Cloud assistant id is required when readSource=clickhouse",
       );
     }
     this.cachedAssistantId = val;

package/src/persistence/llm-request-log-source-clickhouse.ts

@@ -500,7 +500,7 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     const val = await this.resolveAssistantId();
     if (!val) {
       throw new Error(
-        "cadet:platform_assistant_id credential is required when readSource=clickhouse",
+        "Cadet Cloud assistant id is required when readSource=clickhouse",
       );
     }
     this.cachedAssistantId = val;

package/src/runtime/migrations/vbundle-streaming-importer.ts

@@ -1061,9 +1061,9 @@ export async function streamCommitImport(
   }
 
   // Preserve the target's `cadet:*` credential metadata entries across
-  // the swap. Django's post-hatch provisioning on the cloud writes
-  // `cadet:assistant_api_key` / `platform_assistant_id` / `webhook_secret`
-  // via POST /v1/secrets, which upserts into the live
+  // the swap. Django's post-hatch provisioning writes
+  // `cadet:assistant_api_key` / `cadet:webhook_secret` via POST /v1/secrets,
+  // which upserts into the live
   // workspace's `data/credentials/metadata.json`. Without this merge the
   // swap would replace that file with the source's copy (which has no
   // cadet entries on local sources), and the gateway's

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -2206,16 +2206,19 @@ describe("persisted chat settings", () => {
     });
   });
 
-  test("sparse GET exposes effective defaults without materializing unrelated fields", async () => {
+  test("sparse GET returns the fully materialized typed config with effective chat settings", async () => {
     rawConfigFixture = {};
     seedRawConfig();
     invalidateConfigCache();
     const result = await getRoute.handler({});
     expect(result).toMatchObject({
-      conversations: { autoArchive: { enabled: false, afterDays: 7 } },
+      conversations: {
+        autoArchive: { enabled: false, afterDays: 7 },
+        skipAutoRetitling: false,
+      },
       notifications: { newMessageEnabled: true },
     });
-    expect(result).not.toHaveProperty("conversations.skipAutoRetitling");
+    // Materialization is wire-only: nothing is written back to disk.
     expect(loadRawConfig()).not.toHaveProperty("conversations");
     expect(loadRawConfig()).not.toHaveProperty("notifications");
   });
@@ -2235,9 +2238,9 @@ describe("persisted chat settings", () => {
       expect(result).toMatchObject({
         conversations: {
           skipAutoRetitling: true,
-          autoArchive: { enabled: true, afterDays: 30, futureOption: "keep" },
+          autoArchive: { enabled: true, afterDays: 30 },
         },
-        notifications: { newMessageEnabled: false, futureOption: "keep" },
+        notifications: { newMessageEnabled: false },
         maxStepsPerSession: 75,
       });
       expect(loadRawConfig()).toEqual({
@@ -2278,9 +2281,9 @@ describe("persisted chat settings", () => {
     expect(result).toMatchObject({
       conversations: {
         skipAutoRetitling: true,
-        autoArchive: { enabled: false, afterDays: 7, futureOption: "keep" },
+        autoArchive: { enabled: false, afterDays: 7 },
       },
-      notifications: { newMessageEnabled: true, futureOption: "keep" },
+      notifications: { newMessageEnabled: true },
     });
     expect(loadRawConfig()).toMatchObject({
       conversations: { autoArchive: { futureOption: "keep" } },