@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/config/schemas/calls.ts

@@ -26,32 +26,8 @@ const CallsDisclosureConfigSchema = z
     "Controls whether and how the assistant discloses its nature at the start of a phone call",
   );
 
-const CallsSafetyConfigSchema = z
-  .object({
-    denyCategories: z
-      .array(
-        z.string({
-          error: "calls.safety.denyCategories values must be strings",
-        }),
-      )
-      .default([])
-      .describe(
-        "Categories of calls that should be denied (e.g. for safety or compliance reasons)",
-      ),
-  })
-  .describe("Safety guardrails for phone calls");
-
 const CallsVoiceConfigSchema = z
   .object({
-    interruptSensitivity: z
-      .enum(["low", "medium", "high"], {
-        error:
-          "calls.voice.interruptSensitivity must be one of: low, medium, high",
-      })
-      .default("low")
-      .describe(
-        "How aggressively the STT provider detects the start of caller speech — low reduces false interrupts from background noise",
-      ),
     telephonyStreaming: z
       .boolean({
         error: "calls.voice.telephonyStreaming must be a boolean",
@@ -227,7 +203,6 @@ export const CallsConfigSchema = z
     disclosure: CallsDisclosureConfigSchema.default(
       CallsDisclosureConfigSchema.parse({}),
     ),
-    safety: CallsSafetyConfigSchema.default(CallsSafetyConfigSchema.parse({})),
     voice: CallsVoiceConfigSchema.default(CallsVoiceConfigSchema.parse({})),
     callerIdentity: CallerIdentityConfigSchema.default(
       CallerIdentityConfigSchema.parse({}),
@@ -236,6 +211,4 @@ export const CallsConfigSchema = z
       CallsVerificationConfigSchema.parse({}),
     ),
   })
-  .describe(
-    "Phone call configuration — controls telephony, voice, safety, and call behavior",
-  );
+  .describe("Phone call configuration: telephony, voice, and call behavior");

package/src/config/schemas/live-voice.ts

@@ -1,7 +1,5 @@
 import { z } from "zod";
 
-export const VALID_LIVE_VOICE_MODES = ["ptt", "open-mic"] as const;
-
 export const LiveVoiceVadConfigSchema = z
   .object({
     speechEnergyThreshold: z
@@ -79,149 +77,6 @@ export const LiveVoiceVadConfigSchema = z
     "Voice-activity-detection tuning for live voice sessions (open-mic turn segmentation)",
   );
 
-export const LiveVoiceProgressConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({
-        error: "liveVoice.frontModel.progress.enabled must be a boolean",
-      })
-      .default(true)
-      .describe(
-        "Speak short progress updates during long-running tool-heavy turns; the opt-out for progress narration",
-      ),
-    opsThreshold: z
-      .number({
-        error: "liveVoice.frontModel.progress.opsThreshold must be a number",
-      })
-      .int("liveVoice.frontModel.progress.opsThreshold must be an integer")
-      .positive(
-        "liveVoice.frontModel.progress.opsThreshold must be a positive integer",
-      )
-      .default(3)
-      .describe(
-        "Narrate after this many tool operations since the last narration",
-      ),
-    idleIntervalMs: z
-      .number({
-        error: "liveVoice.frontModel.progress.idleIntervalMs must be a number",
-      })
-      .int("liveVoice.frontModel.progress.idleIntervalMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.progress.idleIntervalMs must be a positive integer",
-      )
-      .default(5_000)
-      .describe(
-        "How often (ms) a running turn's silence is checked, and so the soonest new tool activity is narrated",
-      ),
-    maxSilenceMs: z
-      .number({
-        error: "liveVoice.frontModel.progress.maxSilenceMs must be a number",
-      })
-      .int("liveVoice.frontModel.progress.maxSilenceMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.progress.maxSilenceMs must be a positive integer",
-      )
-      .default(35_000)
-      .describe(
-        "Heartbeat ceiling (ms): narrate after this much unbroken silence even when nothing new has happened. Evaluated on the idle tick, so its resolution is idleIntervalMs and it must be at least that long",
-      ),
-    longOpMs: z
-      .number({
-        error: "liveVoice.frontModel.progress.longOpMs must be a number",
-      })
-      .int("liveVoice.frontModel.progress.longOpMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.progress.longOpMs must be a positive integer",
-      )
-      .default(15_000)
-      .describe(
-        "A tool operation that ran at least this long (ms) narrates the moment it completes, without waiting for opsThreshold",
-      ),
-    minGapMs: z
-      .number({
-        error: "liveVoice.frontModel.progress.minGapMs must be a number",
-      })
-      .int("liveVoice.frontModel.progress.minGapMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.progress.minGapMs must be a positive integer",
-      )
-      .default(6_000)
-      .describe(
-        "Minimum spacing (ms) from any spoken floor-holder — ack or narration",
-      ),
-    generationTimeoutMs: z
-      .number({
-        error:
-          "liveVoice.frontModel.progress.generationTimeoutMs must be a number",
-      })
-      .int(
-        "liveVoice.frontModel.progress.generationTimeoutMs must be an integer",
-      )
-      .positive(
-        "liveVoice.frontModel.progress.generationTimeoutMs must be a positive integer",
-      )
-      .default(1_500)
-      .describe(
-        "Budget (ms) for LLM-generated progress text — not latency-critical: it speaks into dead air",
-      ),
-  })
-  // The heartbeat is checked when the idle tick finds the turn silent, so a
-  // ceiling shorter than the tick interval would be missed by up to a full
-  // interval — a promise the cadence cannot keep. Rejecting the combination
-  // beats silently overshooting it.
-  .refine((progress) => progress.maxSilenceMs >= progress.idleIntervalMs, {
-    error:
-      "liveVoice.frontModel.progress.maxSilenceMs must be at least idleIntervalMs — the heartbeat is evaluated on the idle tick",
-  })
-  .describe(
-    "Progress-narration tuning for live voice sessions (spoken updates during long-running turns)",
-  );
-
-export const LiveVoiceFrontModelConfigSchema = z
-  .object({
-    endpointDecisionTimeoutMs: z
-      .number({
-        error:
-          "liveVoice.frontModel.endpointDecisionTimeoutMs must be a number",
-      })
-      .int("liveVoice.frontModel.endpointDecisionTimeoutMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.endpointDecisionTimeoutMs must be a positive integer",
-      )
-      .default(1200)
-      .describe(
-        "Hard budget (ms) for the endpoint decision LLM call. This adds to end-of-turn latency when semantic endpointing is on, so keep it as tight as the decider model's real roundtrip allows — measured Haiku roundtrips through the managed proxy run ~670-1130ms (dev), so tighter budgets turn the feature into a fail-open no-op.",
-      ),
-    endpointExtensionMs: z
-      .number({
-        error: "liveVoice.frontModel.endpointExtensionMs must be a number",
-      })
-      .int("liveVoice.frontModel.endpointExtensionMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.endpointExtensionMs must be a positive integer",
-      )
-      .default(1500)
-      .describe(
-        "How long (ms) a 'hold' decision keeps the turn open before turn-end replays",
-      ),
-    endpointMaxExtensions: z
-      .number({
-        error: "liveVoice.frontModel.endpointMaxExtensions must be a number",
-      })
-      .int("liveVoice.frontModel.endpointMaxExtensions must be an integer")
-      .nonnegative(
-        "liveVoice.frontModel.endpointMaxExtensions must be a nonnegative integer",
-      )
-      .default(2)
-      .describe("Cap on consecutive 'hold' extensions per utterance"),
-    progress: LiveVoiceProgressConfigSchema.default(
-      LiveVoiceProgressConfigSchema.parse({}),
-    ),
-  })
-  .describe(
-    "Voice front-door endpointing and long-turn progress narration tuning",
-  );
-
 const LiveVoiceFluxTurnEndConfigSchema = z
   .object({
     enabled: z
@@ -285,31 +140,10 @@ export const LiveVoiceFluxConfigSchema = z
 
 export const LiveVoiceConfigSchema = z
   .object({
-    mode: z
-      .enum(VALID_LIVE_VOICE_MODES, {
-        error: `liveVoice.mode must be one of: ${VALID_LIVE_VOICE_MODES.join(", ")}`,
-      })
-      .default("open-mic")
-      .describe(
-        "Default microphone mode for live voice sessions — hands-free (open-mic) or push-to-talk (ptt)",
-      ),
     vad: LiveVoiceVadConfigSchema.default(LiveVoiceVadConfigSchema.parse({})),
-    frontModel: LiveVoiceFrontModelConfigSchema.default(
-      LiveVoiceFrontModelConfigSchema.parse({}),
-    ),
     flux: LiveVoiceFluxConfigSchema.default(
       LiveVoiceFluxConfigSchema.parse({}),
     ),
-    maxSessionDurationSeconds: z
-      .number({
-        error: "liveVoice.maxSessionDurationSeconds must be a number",
-      })
-      .int("liveVoice.maxSessionDurationSeconds must be an integer")
-      .positive(
-        "liveVoice.maxSessionDurationSeconds must be a positive integer",
-      )
-      .default(1800)
-      .describe("Maximum duration of a single live voice session in seconds"),
     archiveAudio: z
       .boolean({ error: "liveVoice.archiveAudio must be a boolean" })
       .default(false)
@@ -318,15 +152,9 @@ export const LiveVoiceConfigSchema = z
       ),
   })
   .describe(
-    "Live voice (in-app duplex audio) configuration — mic mode, VAD tuning, and session limits",
+    "Live voice (in-app duplex audio) configuration: VAD tuning, Flux turn detection, and audio archiving",
   );
 
 export type LiveVoiceConfig = z.infer<typeof LiveVoiceConfigSchema>;
 export type LiveVoiceVadConfig = z.infer<typeof LiveVoiceVadConfigSchema>;
-export type LiveVoiceFrontModelConfig = z.infer<
-  typeof LiveVoiceFrontModelConfigSchema
->;
-export type LiveVoiceProgressConfig = z.infer<
-  typeof LiveVoiceProgressConfigSchema
->;
 export type LiveVoiceFluxConfig = z.infer<typeof LiveVoiceFluxConfigSchema>;

package/src/config/schemas/mcp.ts

@@ -102,7 +102,7 @@ export type McpServerConfig = z.infer<typeof McpServerConfigSchema>;
 export type McpConfig = z.infer<typeof McpConfigSchema>;
 
 /**
- * Who declared a server: the workspace `config.json`, which the user owns,
+ * Who declared a server: the workspace `mcp.json`, which the user owns,
  * or a plugin's `mcp.json`, which its author owns.
  *
  * Deliberately not a schema field. It is resolved from where the entry was

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

@@ -9,6 +9,16 @@ export const MemoryRetrospectiveConfigSchema = z
         "Whether the memory-retrospective background pass runs. When false, no retrospective is enqueued by any trigger (interval, message count, pre-compaction, scheduled sweep), the scheduled sweep job stops being queued, and any row already queued completes as a no-op. The rest of the memory system (extraction, retrieval, embeddings, `<memory>` injection) is unaffected. Use `memory.enabled` to disable memory as a whole.",
       ),
 
+    skillImprovement: z
+      .boolean({
+        error:
+          "memory.retrospective.skillImprovement must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Whether retrospectives may discover, refine, and create managed skills from observed procedures. When false, retrospectives still capture ordinary memories through `remember`, but cannot load skill management, search for similar skills, or scaffold managed skills.",
+      ),
+
     timeThresholdMs: z
       .number({
         error: "memory.retrospective.timeThresholdMs must be a number",

package/src/config/schemas/services.ts

@@ -140,6 +140,11 @@ const MondayOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 
+export const ShopifyOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type ShopifyOAuthService = z.infer<typeof ShopifyOAuthServiceSchema>;
+
 export const StripeLinkOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
@@ -152,6 +157,13 @@ export const FigmaOAuthServiceSchema = BaseServiceSchema.extend({
 });
 export type FigmaOAuthService = z.infer<typeof FigmaOAuthServiceSchema>;
 
+export const QuickBooksOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type QuickBooksOAuthService = z.infer<
+  typeof QuickBooksOAuthServiceSchema
+>;
+
 export const EventbriteOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
@@ -214,12 +226,18 @@ export const ServicesSchema = z.object({
   "monday-oauth": MondayOAuthServiceSchema.default(
     MondayOAuthServiceSchema.parse({}),
   ),
+  "shopify-oauth": ShopifyOAuthServiceSchema.default(
+    ShopifyOAuthServiceSchema.parse({}),
+  ),
   "stripe-link-oauth": StripeLinkOAuthServiceSchema.default(
     StripeLinkOAuthServiceSchema.parse({}),
   ),
   "figma-oauth": FigmaOAuthServiceSchema.default(
     FigmaOAuthServiceSchema.parse({}),
   ),
+  "quickbooks-oauth": QuickBooksOAuthServiceSchema.default(
+    QuickBooksOAuthServiceSchema.parse({}),
+  ),
   "eventbrite-oauth": EventbriteOAuthServiceSchema.default(
     EventbriteOAuthServiceSchema.parse({}),
   ),

package/src/config/schemas/skills.ts

@@ -32,20 +32,6 @@ const SkillsLoadConfigSchema = z
       )
       .default([])
       .describe("Additional directories to search for skill definitions"),
-    watch: z
-      .boolean({ error: "skills.load.watch must be a boolean" })
-      .default(true)
-      .describe(
-        "Whether to watch skill directories for changes and auto-reload",
-      ),
-    watchDebounceMs: z
-      .number({ error: "skills.load.watchDebounceMs must be a number" })
-      .int()
-      .positive()
-      .default(250)
-      .describe(
-        "Debounce delay in milliseconds for skill file change detection",
-      ),
   })
   .describe("Controls how skills are discovered and loaded");
 

package/src/config/schemas/voice.ts

@@ -0,0 +1,150 @@
+import { z } from "zod";
+
+export const VoiceProgressConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({
+        error: "voice.frontModel.progress.enabled must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Speak short progress updates during long-running tool-heavy turns; the opt-out for progress narration",
+      ),
+    opsThreshold: z
+      .number({
+        error: "voice.frontModel.progress.opsThreshold must be a number",
+      })
+      .int("voice.frontModel.progress.opsThreshold must be an integer")
+      .positive(
+        "voice.frontModel.progress.opsThreshold must be a positive integer",
+      )
+      .default(3)
+      .describe(
+        "Narrate after this many tool operations since the last narration",
+      ),
+    idleIntervalMs: z
+      .number({
+        error: "voice.frontModel.progress.idleIntervalMs must be a number",
+      })
+      .int("voice.frontModel.progress.idleIntervalMs must be an integer")
+      .positive(
+        "voice.frontModel.progress.idleIntervalMs must be a positive integer",
+      )
+      .default(5_000)
+      .describe(
+        "How often (ms) a running turn's silence is checked, and so the soonest new tool activity is narrated",
+      ),
+    maxSilenceMs: z
+      .number({
+        error: "voice.frontModel.progress.maxSilenceMs must be a number",
+      })
+      .int("voice.frontModel.progress.maxSilenceMs must be an integer")
+      .positive(
+        "voice.frontModel.progress.maxSilenceMs must be a positive integer",
+      )
+      .default(35_000)
+      .describe(
+        "Heartbeat ceiling (ms): narrate after this much unbroken silence even when nothing new has happened. Evaluated on the idle tick, so its resolution is idleIntervalMs and it must be at least that long",
+      ),
+    longOpMs: z
+      .number({
+        error: "voice.frontModel.progress.longOpMs must be a number",
+      })
+      .int("voice.frontModel.progress.longOpMs must be an integer")
+      .positive("voice.frontModel.progress.longOpMs must be a positive integer")
+      .default(15_000)
+      .describe(
+        "A tool operation that ran at least this long (ms) narrates the moment it completes, without waiting for opsThreshold",
+      ),
+    minGapMs: z
+      .number({
+        error: "voice.frontModel.progress.minGapMs must be a number",
+      })
+      .int("voice.frontModel.progress.minGapMs must be an integer")
+      .positive("voice.frontModel.progress.minGapMs must be a positive integer")
+      .default(6_000)
+      .describe(
+        "Minimum spacing (ms) from any spoken floor-holder (ack or narration)",
+      ),
+    generationTimeoutMs: z
+      .number({
+        error: "voice.frontModel.progress.generationTimeoutMs must be a number",
+      })
+      .int("voice.frontModel.progress.generationTimeoutMs must be an integer")
+      .positive(
+        "voice.frontModel.progress.generationTimeoutMs must be a positive integer",
+      )
+      .default(1_500)
+      .describe(
+        "Budget (ms) for LLM-generated progress text. Not latency-critical: it speaks into dead air",
+      ),
+  })
+  // The heartbeat is checked when the idle tick finds the turn silent, so a
+  // ceiling shorter than the tick interval would be missed by up to a full
+  // interval, a promise the cadence cannot keep. Rejecting the combination
+  // beats silently overshooting it.
+  .refine((progress) => progress.maxSilenceMs >= progress.idleIntervalMs, {
+    error:
+      "voice.frontModel.progress.maxSilenceMs must be at least idleIntervalMs: the heartbeat is evaluated on the idle tick",
+  })
+  .describe(
+    "Progress-narration tuning for live voice sessions (spoken updates during long-running turns)",
+  );
+
+export const VoiceFrontModelConfigSchema = z
+  .object({
+    endpointDecisionTimeoutMs: z
+      .number({
+        error: "voice.frontModel.endpointDecisionTimeoutMs must be a number",
+      })
+      .int("voice.frontModel.endpointDecisionTimeoutMs must be an integer")
+      .positive(
+        "voice.frontModel.endpointDecisionTimeoutMs must be a positive integer",
+      )
+      .default(1200)
+      .describe(
+        "Hard budget (ms) for the endpoint decision LLM call. This adds to end-of-turn latency when semantic endpointing is on, so keep it as tight as the decider model's real roundtrip allows. Measured Haiku roundtrips through the managed proxy run ~670-1130ms (dev), so tighter budgets turn the feature into a fail-open no-op.",
+      ),
+    endpointExtensionMs: z
+      .number({
+        error: "voice.frontModel.endpointExtensionMs must be a number",
+      })
+      .int("voice.frontModel.endpointExtensionMs must be an integer")
+      .positive(
+        "voice.frontModel.endpointExtensionMs must be a positive integer",
+      )
+      .default(1500)
+      .describe(
+        "How long (ms) a 'hold' decision keeps the turn open before turn-end replays",
+      ),
+    endpointMaxExtensions: z
+      .number({
+        error: "voice.frontModel.endpointMaxExtensions must be a number",
+      })
+      .int("voice.frontModel.endpointMaxExtensions must be an integer")
+      .nonnegative(
+        "voice.frontModel.endpointMaxExtensions must be a nonnegative integer",
+      )
+      .default(2)
+      .describe("Cap on consecutive 'hold' extensions per utterance"),
+    progress: VoiceProgressConfigSchema.default(
+      VoiceProgressConfigSchema.parse({}),
+    ),
+  })
+  .describe(
+    "Voice front-door endpointing and long-turn progress narration tuning, shared by live voice and phone calls",
+  );
+
+export const VoiceConfigSchema = z
+  .object({
+    frontModel: VoiceFrontModelConfigSchema.default(
+      VoiceFrontModelConfigSchema.parse({}),
+    ),
+  })
+  .describe(
+    "Transport-agnostic voice configuration shared by live voice and phone calls: front-door routing and progress narration tuning",
+  );
+
+export type VoiceConfig = z.infer<typeof VoiceConfigSchema>;
+export type VoiceFrontModelConfig = z.infer<typeof VoiceFrontModelConfigSchema>;
+export type VoiceProgressConfig = z.infer<typeof VoiceProgressConfigSchema>;

package/src/credential-execution/process-manager.test.ts

@@ -12,8 +12,15 @@ import {
   test,
 } from "bun:test";
 
+import { waitFor } from "../__tests__/helpers/wait-for.js";
 import { createCesProcessManager } from "./process-manager.js";
 
+const untilClosed = (predicate: () => boolean) =>
+  waitFor(predicate, {
+    timeoutMs: 2000,
+    message: "socket close never propagated to the transport",
+  });
+
 // ---------------------------------------------------------------------------
 // onTransportClose tests
 // ---------------------------------------------------------------------------
@@ -79,10 +86,7 @@ describe("CesProcessManager.onTransportClose", () => {
       sock.destroy();
     }
 
-    // Give the close event a tick to propagate.
-    await new Promise((resolve) => setTimeout(resolve, 50));
-
-    expect(closeFired).toBe(true);
+    await untilClosed(() => closeFired);
     expect(transport.isAlive()).toBe(false);
 
     await pm.stop();
@@ -112,8 +116,7 @@ describe("CesProcessManager.onTransportClose", () => {
     for (const sock of connections) {
       sock.destroy();
     }
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    expect(transport.isAlive()).toBe(false);
+    await untilClosed(() => !transport.isAlive());
 
     // Register handler AFTER transport is already dead.
     let closeFired = false;
@@ -190,14 +193,12 @@ describe("CesProcessManager transport-death logging", () => {
     for (const sock of connections) {
       sock.destroy();
     }
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    expect(transport.isAlive()).toBe(false);
-
-    expect(
+    await untilClosed(() =>
       calls.some(
         (c) => c.level === "warn" && c.msg.includes("died unexpectedly"),
       ),
-    ).toBe(true);
+    );
+    expect(transport.isAlive()).toBe(false);
 
     await pm.stop();
   });
@@ -208,19 +209,17 @@ describe("CesProcessManager transport-death logging", () => {
     await pm.start();
 
     await pm.stop();
-    // Let the socket close event propagate after destroy().
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await untilClosed(() =>
+      calls.some(
+        (c) =>
+          c.level === "debug" && c.msg.includes("CES socket transport closed"),
+      ),
+    );
 
     expect(
       calls.some(
         (c) => c.level === "warn" && c.msg.includes("died unexpectedly"),
       ),
     ).toBe(false);
-    expect(
-      calls.some(
-        (c) =>
-          c.level === "debug" && c.msg.includes("CES socket transport closed"),
-      ),
-    ).toBe(true);
   });
 });

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

@@ -34,10 +34,7 @@ import {
   type OAuthConnectionRow,
   type OAuthProviderRow,
 } from "../oauth/oauth-store.js";
-import {
-  expectedScopesForStoredToken,
-  scopeDifference,
-} from "../oauth/scope-utils.js";
+import { missingScopesForStoredToken } from "../oauth/scope-utils.js";
 import { credentialKey } from "../security/credential-key.js";
 import {
   getSecureKeyAsync,
@@ -294,26 +291,23 @@ async function checkConnection(
   // token rather than the provider's bot-side `scope` parameter. A provider
   // asking for user scopes as well stores the user token and records that
   // token's grant, so the bot request names scopes that grant can never hold.
-  const grantedScopes = safeJsonParse<string[]>(grantedScopesRaw, []);
-  const expectedScopes = expectedScopesForStoredToken(
+  const missing = missingScopesForStoredToken(
     safeJsonParse<string[]>(defaultScopesRaw, []),
     safeJsonParse<Record<string, string> | undefined>(
       authorizeParamsRaw,
       undefined,
     ),
     scopeSeparator ?? undefined,
+    safeJsonParse<string[]>(grantedScopesRaw, []),
   );
-  if (expectedScopes.length > 0 && grantedScopes.length > 0) {
-    const missing = scopeDifference(expectedScopes, grantedScopes);
-    if (missing.length > 0) {
-      return {
-        ...base,
-        status: "missing_scopes",
-        details: `${provider} is missing required scopes: ${missing.join(", ")}. Features may not work correctly.`,
-        missingScopes: missing,
-        canAutoRecover: false,
-      };
-    }
+  if (missing.length > 0) {
+    return {
+      ...base,
+      status: "missing_scopes",
+      details: `${provider} is missing required scopes: ${missing.join(", ")}. Features may not work correctly.`,
+      missingScopes: missing,
+      canAutoRecover: false,
+    };
   }
 
   // 4. Liveness ping