@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/plugins/pipeline.ts

@@ -17,11 +17,13 @@
  * Design doc: `.private/plans/agent-plugin-system.md`.
  */
 
+import { z } from "zod";
+
 import { makeHookBroadcast } from "../hooks/hook-broadcast.js";
 import { makeHookLogger } from "../hooks/hook-logger.js";
 import { getHookEntriesFor } from "../hooks/registry.js";
 import type { BaseHookContext } from "../hooks/types.js";
-import type { HookName } from "../plugin-api/constants.js";
+import { type HookName, HOOKS } from "../plugin-api/constants.js";
 import { getLogger } from "../util/logger.js";
 import type { HookEntry } from "./types.js";
 
@@ -109,6 +111,181 @@ function cloneHookValue<T>(value: T, seen = new WeakMap<object, unknown>()): T {
   return copy as T;
 }
 
+// ─── Hook output sanitization ────────────────────────────────────────────────
+
+/**
+ * Schemas for the message shapes hooks may hand back. They require exactly
+ * the fields the loop and serializers read without guards (e.g.
+ * `block.id.length` on every tool_use, `source.media_type` on media blocks);
+ * unknown block types pass — serializers already drop them safely.
+ */
+const MediaSourceSchema = z.discriminatedUnion("type", [
+  z.looseObject({
+    type: z.literal("base64"),
+    data: z.string(),
+    media_type: z.string(),
+  }),
+  z.looseObject({
+    type: z.literal("workspace_ref"),
+    attachmentId: z.string(),
+    media_type: z.string(),
+    sizeBytes: z.number(),
+  }),
+]);
+
+const KNOWN_BLOCK_TYPES = new Set([
+  "text",
+  "thinking",
+  "redacted_thinking",
+  "tool_use",
+  "server_tool_use",
+  "tool_result",
+  "web_search_tool_result",
+  "image",
+  "file",
+]);
+
+// tool_result `content` must be a string (serializers concatenate it); rich
+// content lives in `contentBlocks`, validated recursively because media
+// resolution recurses into it.
+const ToolResultSchema = z.looseObject({
+  type: z.literal("tool_result"),
+  tool_use_id: z.string(),
+  content: z.string(),
+  contentBlocks: z.lazy(() => z.array(ContentBlockSchema).optional()),
+});
+
+const ContentBlockSchema: z.ZodType<unknown> = z.lazy(() =>
+  z.union([
+    z.looseObject({ type: z.literal("text"), text: z.string() }),
+    z.looseObject({
+      type: z.literal("thinking"),
+      thinking: z.string(),
+      signature: z.string(),
+    }),
+    z.looseObject({ type: z.literal("redacted_thinking"), data: z.string() }),
+    z.looseObject({
+      type: z.enum(["tool_use", "server_tool_use"]),
+      id: z.string(),
+      name: z.string(),
+      input: z.record(z.string(), z.unknown()),
+    }),
+    ToolResultSchema,
+    // `content` is an opaque provider-specific payload — unchecked.
+    z.looseObject({
+      type: z.literal("web_search_tool_result"),
+      tool_use_id: z.string(),
+    }),
+    z.looseObject({
+      type: z.enum(["image", "file"]),
+      source: MediaSourceSchema,
+    }),
+    z
+      .looseObject({ type: z.string() })
+      .refine((block) => !KNOWN_BLOCK_TYPES.has(block.type)),
+  ]),
+);
+
+const MessageSchema = z.looseObject({
+  role: z.enum(["user", "assistant"]),
+  content: z.array(ContentBlockSchema),
+});
+
+/**
+ * Per-hook schemas for the context fields the loop folds back into the turn
+ * verbatim — a malformed message there fails every subsequent provider call.
+ * Loose + optional: unknown context keys pass, and absent fields are skipped
+ * (call sites and tests may dispatch a hook name with a partial context).
+ */
+const HOOK_OUTPUT_SCHEMAS: Partial<
+  Record<HookName, z.ZodObject<z.ZodRawShape>>
+> = {
+  [HOOKS.USER_PROMPT_SUBMIT]: z.looseObject({
+    latestMessages: z.array(MessageSchema).optional(),
+  }),
+  [HOOKS.POST_COMPACT]: z.looseObject({
+    history: z.array(MessageSchema).optional(),
+  }),
+  [HOOKS.POST_MODEL_CALL]: z.looseObject({
+    messages: z.array(MessageSchema).optional(),
+    content: z.array(ContentBlockSchema).optional(),
+  }),
+  // Strictly a client tool_result: only it can pair back to the assistant's
+  // tool_use — a server-tool web_search_tool_result replacement is rejected.
+  [HOOKS.POST_TOOL_USE]: z.looseObject({
+    toolResponse: ToolResultSchema.optional(),
+  }),
+};
+
+/**
+ * Detect malformed message data in a hook's output. Read-only: a non-empty
+ * result means the caller discards the hook's entire mutation and keeps the
+ * previous context.
+ */
+function findHookOutputIssues<TInput extends object>(
+  name: HookName,
+  ctx: TInput,
+): string[] {
+  const schema = HOOK_OUTPUT_SCHEMAS[name];
+  if (!schema) {
+    return [];
+  }
+  const issues: string[] = [];
+  // `.optional()` lets an absent field skip validation, but it also lets a
+  // hook REPLACE a required field with an explicit `undefined` — which the
+  // loop would then fold back and dereference. Reject present-but-undefined.
+  const rec = ctx as Record<string, unknown>;
+  for (const key of Object.keys(schema.shape)) {
+    if (key in rec && rec[key] === undefined) {
+      issues.push(`${key}: replaced with undefined`);
+    }
+  }
+  const parsed = schema.safeParse(ctx);
+  if (!parsed.success) {
+    issues.push(
+      ...parsed.error.issues.map(
+        (issue) => `${issue.path.join(".")}: ${issue.message}`,
+      ),
+    );
+  }
+  return issues;
+}
+
+// ─── Hook execution timeout ──────────────────────────────────────────────────
+
+/**
+ * Time-box for a single hook invocation: the try/catch contains throws but
+ * not hangs.
+ *
+ * Covers async hangs only: a CPU-bound synchronous loop never yields to the
+ * event loop, so the timeout cannot fire until it returns. Preempting that
+ * needs worker-thread isolation, which the in-process hook contract (contexts
+ * carry non-cloneable capabilities like `logger`/`broadcast`) does not
+ * currently allow.
+ */
+export const HOOK_TIMEOUT_MS = 30_000;
+
+export async function callWithTimeout<T>(
+  run: () => Promise<T> | T,
+  timeoutMs: number,
+  timeoutMessage: string,
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const work = Promise.resolve().then(run);
+    // Absorb the abandoned hook's late rejection if the timeout wins.
+    work.catch(() => {});
+    return await Promise.race([
+      work,
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 /**
  * Execute a hook chain: walk every registered plugin's hook for `name` in
  * registration order, threading `initialCtx` through each. Hooks may either
@@ -119,6 +296,10 @@ function cloneHookValue<T>(value: T, seen = new WeakMap<object, unknown>()): T {
  * successfully committed context. The final context after the chain settles is
  * returned.
  *
+ * Fail-open guards: a hook whose output carries malformed message data
+ * ({@link findHookOutputIssues}) has its entire mutation discarded, and every
+ * hook is time-boxed so a hung hook cannot block the turn.
+ *
  * When `initialCtx` carries a `conversationId`, it is passed to
  * {@link getHookEntriesFor}, which resolves the conversation's per-chat plugin
  * scope (memory, then DB) and skips a hook whose contributing plugin is outside
@@ -171,11 +352,20 @@ export async function runHook<TInput extends object>(
       broadcast: makeHookBroadcast({ conversationId, hookName: name, owner }),
     };
     try {
-      const result = await fn(draft);
-      if (result !== undefined) {
-        active = { ...draft, ...result };
+      const result = await callWithTimeout(
+        () => fn(draft),
+        HOOK_TIMEOUT_MS,
+        `plugin hook '${name}' (${owner.id}) timed out after ${HOOK_TIMEOUT_MS}ms`,
+      );
+      const candidate = result !== undefined ? { ...draft, ...result } : draft;
+      const issues = findHookOutputIssues(name, candidate);
+      if (issues.length > 0) {
+        log.error(
+          { hookName: name, owner, issues },
+          "plugin hook produced malformed message data — skipping this hook",
+        );
       } else {
-        active = draft;
+        active = candidate;
       }
     } catch (err) {
       log.error(

package/src/plugins/surface-import.ts

@@ -70,6 +70,47 @@ export function evictModule(filePath: string): void {
   delete require.cache[filePath];
 }
 
+/**
+ * Error a {@link withTimeout} race rejects with when the deadline wins. Named
+ * so callers that time-box user code can tell "the wrapped promise took too
+ * long" apart from "the wrapped promise itself rejected".
+ */
+export class TimeoutError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+
+/**
+ * Reject with a {@link TimeoutError} after `ms` if `p` hasn't settled. The
+ * losing promise is abandoned, not cancelled — the caller must treat a timeout
+ * as best-effort and swallow any late rejection from the abandoned promise.
+ *
+ * This is the one place surface paths time-box user code: the surface import
+ * itself ({@link importWithTimeout}) and the hook runner's `shutdown`
+ * invocation both wrap through here so the deadline logic lives once.
+ */
+export function withTimeout<T>(
+  p: Promise<T>,
+  ms: number,
+  message: string,
+): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new TimeoutError(message)), ms);
+    p.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      },
+    );
+  });
+}
+
 /**
  * In-flight import promises, keyed by file path. Prevents duplicate
  * `import()` calls when multiple readers request the same surface
@@ -81,21 +122,22 @@ const inflight = new Map<string, Promise<unknown>>();
  * Import a module's default export with a timeout. If the import doesn't
  * resolve within `timeoutMs`, logs a warning and returns `undefined` so a
  * hanging module doesn't block daemon startup indefinitely. Defaults to the
- * module-level {@link getSurfaceImportTimeout}.
+ * module-level {@link getSurfaceImportTimeout}. A genuine import failure (not a
+ * timeout) propagates so the caller can log and cache it as absent.
  */
 export async function importWithTimeout<T>(
   filePath: string,
   timeoutMs: number = importTimeoutMs,
 ): Promise<T | undefined> {
-  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+  const importPromise = importWithDedup<T>(filePath);
   try {
-    const timeoutSentinel = Symbol("import-timeout");
-    const importPromise = importWithDedup<T>(filePath);
-    const timeoutPromise = new Promise<typeof timeoutSentinel>((resolve) => {
-      timeoutHandle = setTimeout(() => resolve(timeoutSentinel), timeoutMs);
-    });
-    const result = await Promise.race([importPromise, timeoutPromise]);
-    if (result === timeoutSentinel) {
+    return await withTimeout<T>(
+      importPromise,
+      timeoutMs,
+      `Import timed out after ${timeoutMs}ms — skipping surface`,
+    );
+  } catch (err) {
+    if (err instanceof TimeoutError) {
       importPromise.catch(() => {
         /* swallow — late rejection from abandoned import */
       });
@@ -105,11 +147,7 @@ export async function importWithTimeout<T>(
       );
       return undefined;
     }
-    return result as T;
-  } finally {
-    if (timeoutHandle !== undefined) {
-      clearTimeout(timeoutHandle);
-    }
+    throw err;
   }
 }
 

package/src/plugins/types.ts

@@ -13,19 +13,19 @@ import type { CompactionCircuitClosedEvent } from "../api/events/compaction-circ
 import type { CompactionCircuitOpenEvent } from "../api/events/compaction-circuit-open.js";
 import type { HookEventOwner } from "../api/events/hook-event.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import type { AssistantConfig } from "../config/types.js";
 import type {
   ChannelCapabilities,
   InboundActorContext,
   InjectionMode,
 } from "../daemon/conversation-runtime-assembly.js";
-import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
+import type { MemoryJob } from "../persistence/jobs-store.js";
 import type { HookFunction } from "../plugin-api/types.js";
 import type { Message } from "../providers/types.js";
 import type { SkillRoute } from "../runtime/skill-route-registry.js";
 import type { Tool } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
-import type { ConversationGraphMemory } from "./defaults/memory/graph/conversation-graph-memory.js";
-import type { JobHandler } from "./defaults/memory/jobs-worker.js";
 
 // ─── Manifest ────────────────────────────────────────────────────────────────
 
@@ -68,18 +68,6 @@ export type {
   ShutdownReason,
 } from "../plugin-api/types.js";
 
-// ─── Memory-graph result ─────────────────────────────────────────────────────
-
-/**
- * Full output of a single memory-graph retrieval — the object returned by
- * {@link ConversationGraphMemory.prepareMemory} (injected messages, query
- * vectors, metrics). The agent loop consumes these fields directly to drive
- * PKB hint search and runtime injection.
- */
-export type GraphMemoryResult = Awaited<
-  ReturnType<ConversationGraphMemory["prepareMemory"]>
->;
-
 /**
  * The complete set of compaction circuit-breaker transition events:
  * `compaction_circuit_open` when the breaker trips and `compaction_circuit_closed`
@@ -336,6 +324,13 @@ export interface Injector {
  */
 export type PluginRouteRegistration = SkillRoute;
 
+/**
+ * Processes one claimed background job: receives the claimed job row and the
+ * live assistant config. The return value is ignored — a handler signals
+ * failure by throwing, which the worker records against the job.
+ */
+export type JobHandler = (job: MemoryJob, config: AssistantConfig) => unknown;
+
 /**
  * A single background-job-handler entry: a job `type` string paired with the
  * {@link JobHandler} that processes it. The memory plugin's handler list

package/src/prompts/persona-resolver.ts

@@ -10,7 +10,7 @@ import {
   peekCachedGuardianDelivery,
 } from "../contacts/guardian-delivery-reader.js";
 import type { ChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
-import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir, getWorkspacePromptPath } from "../util/platform.js";
 import { stripCommentLines } from "../util/strip-comment-lines.js";

package/src/prompts/system-prompt.ts

@@ -10,10 +10,8 @@ import { join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
 import type { ChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
-import {
-  resolveTrustClass,
-  type TrustContext,
-} from "../daemon/trust-context.js";
+import { resolveTrustClass } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { markActivationSession } from "../plugins/defaults/memory/activation-session-store.js";
 import { derivePersonaTrustFlags } from "../runtime/trust-class.js";
 import { ACTIVATION_RAIL_BOOTSTRAP_TEMPLATE } from "../telemetry/activation-funnel.js";

package/src/prompts/templates/system-sections.ts

@@ -296,6 +296,18 @@ Use \`assistant platform status\` to check the current Vellum platform connectio
 Run \`assistant --help\` to see all available commands, or \`assistant <command> --help\` for detailed help on any subcommand.
 
 **Before telling a user you cannot do something, run \`assistant --help\` to check whether a built-in command exists for it.** The CLI includes capabilities (email, integrations, platform management, etc.) that you may not know about from training data alone. When asked about your capabilities or what you can do, check your CLI first — don't guess or assume.
+`,
+  },
+  {
+    // TODO(LUM-2758): add a behavioral eval in vellum-ai/evals — seed a stale
+    // "all connected" memory while the live connection is broken, ask a state
+    // question, and assert the agent runs a live check (oauth status / watchers
+    // list) instead of answering from memory. Guards this guidance from silent
+    // regression.
+    id: "03a-verify-live-state",
+    body: `## Trust live state over memory
+
+Memory and auto-injected context record the **past** and can be stale. For anything verifiable and volatile — connection, credential, or account status; whether something is running or being monitored; config values; live data — don't answer or act from memory. Check it live first (e.g. \`assistant oauth status <provider>\`, \`assistant watchers list\`, or the relevant CLI/tool) and answer from that. This matters most right before you assert a state or act on it. If a live check contradicts memory, the check wins.
 `,
   },
   {

package/src/providers/__tests__/connection-model-compat.test.ts

@@ -69,11 +69,6 @@ describe("isConnectionCompatibleWithModel", () => {
 // be declared before the import-under-test.
 // ---------------------------------------------------------------------------
 
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 let mockLlmConfig: Record<string, unknown> = {};
 
 mock.module("../../config/loader.js", () => ({

package/src/providers/__tests__/count-tokens-forwarding.test.ts

@@ -5,27 +5,7 @@
  * chain and `/compact` silently falls back to the local estimate. These tests
  * pin the forwarding.
  */
-import { describe, expect, mock, test } from "bun:test";
-
-function makeLoggerStub(): Record<string, unknown> {
-  const stub: Record<string, unknown> = {};
-  for (const m of [
-    "info",
-    "warn",
-    "error",
-    "debug",
-    "trace",
-    "fatal",
-    "silent",
-    "child",
-  ]) {
-    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
-  }
-  return stub;
-}
-mock.module("../../util/logger.js", () => ({
-  getLogger: () => makeLoggerStub(),
-}));
+import { describe, expect, test } from "bun:test";
 
 import { CallSiteRoutingProvider } from "../call-site-routing.js";
 import { RateLimitProvider } from "../ratelimit.js";

package/src/providers/__tests__/dispatch-connection-routing.test.ts

@@ -23,17 +23,23 @@
  *      what to do).
  */
 
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+
+// Connection-routing plumbing over legacy-shaped fixtures (llm.default /
+// activeProfile-centric, no defaultProvider): pinned to the flag-off
+// cascade. Flag-on dispatch behavior is covered by
+// inference-no-mode-boot-e2e.test.ts and the override-or-default resolver
+// suite.
+beforeAll(() => {
+  setOverridesForTesting({ "override-or-default-resolution": false });
+});
 
 // ---------------------------------------------------------------------------
 // Module mocks (must be declared before the import-under-test).
 // ---------------------------------------------------------------------------
 
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 // Test fixtures for the mocked config loader.
 let mockLlmConfig: Record<string, unknown> = {};
 

package/src/providers/__tests__/preflight-resolved-config.test.ts

@@ -0,0 +1,189 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let connectionsByName: Record<string, unknown> = {};
+let secureKeys: Record<string, string | undefined> = {};
+let cesUnreachable = false;
+let platformLoggedIn = false;
+
+mock.module("../../persistence/db-connection.js", () => ({
+  getDb: () => ({}),
+}));
+
+mock.module("../inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) =>
+    connectionsByName[name] ?? null,
+  listConnections: () => [],
+}));
+
+mock.module("../provider-availability.js", () => ({
+  checkCredentialPresence: async (account: string) =>
+    cesUnreachable
+      ? "indeterminate"
+      : secureKeys[account] != null
+        ? "present"
+        : "absent",
+}));
+
+mock.module("../platform-proxy/context.js", () => ({
+  hasManagedProxyPrereqs: async () => platformLoggedIn,
+  resolveManagedProxyContext: async () => ({
+    enabled: platformLoggedIn,
+    // Base URL configured: an unauthenticated result must come from the
+    // credential probe, so CES outages stay distinguishable.
+    platformBaseUrl: "https://platform",
+    assistantApiKey: platformLoggedIn ? "key" : "",
+  }),
+}));
+
+import {
+  ConnectionResolutionError,
+  preflightResolvedConfig,
+} from "../connection-resolution.js";
+
+const resolved = (overrides: Partial<Record<string, string>> = {}) => ({
+  provider: "anthropic",
+  provider_connection: "anthropic-personal",
+  model: "claude-opus-4-8",
+  ...overrides,
+});
+
+async function preflightError(
+  config: ReturnType<typeof resolved>,
+): Promise<ConnectionResolutionError | undefined> {
+  try {
+    await preflightResolvedConfig(config, { profileName: "custom-fast" });
+    return undefined;
+  } catch (err) {
+    expect(err).toBeInstanceOf(ConnectionResolutionError);
+    return err as ConnectionResolutionError;
+  }
+}
+
+beforeEach(() => {
+  secureKeys = {};
+  connectionsByName = {
+    "anthropic-personal": {
+      name: "anthropic-personal",
+      provider: "anthropic",
+      auth: {
+        type: "api_key",
+        credential: "credential/anthropic/api_key",
+      },
+    },
+  };
+  secureKeys = { "credential/anthropic/api_key": "sk-ant" };
+  cesUnreachable = false;
+  platformLoggedIn = false;
+});
+
+describe("preflightResolvedConfig", () => {
+  test("healthy config passes silently", async () => {
+    expect(await preflightError(resolved())).toBeUndefined();
+  });
+
+  test("no provider_connection on the config is not the preflight's concern", async () => {
+    await preflightResolvedConfig(
+      { provider: "anthropic", model: "claude-opus-4-8" },
+      {},
+    );
+  });
+
+  test("deleted connection throws not_found naming profile and model", async () => {
+    connectionsByName = {};
+    const err = await preflightError(resolved());
+    expect(err?.reason).toBe("not_found");
+    expect(err?.profileName).toBe("custom-fast");
+    expect(err?.model).toBe("claude-opus-4-8");
+    expect(err?.message).toContain("anthropic-personal");
+  });
+
+  test("missing credential throws missing_credential", async () => {
+    secureKeys = {};
+    const err = await preflightError(resolved());
+    expect(err?.reason).toBe("missing_credential");
+    expect(err?.message).toContain("API key");
+  });
+
+  test("CES-unreachable passes silently — never misreported as a missing credential", async () => {
+    secureKeys = {};
+    cesUnreachable = true;
+    expect(await preflightError(resolved())).toBeUndefined();
+  });
+
+  test("provider mismatch throws provider_mismatch", async () => {
+    connectionsByName["anthropic-personal"] = {
+      name: "anthropic-personal",
+      provider: "openai",
+      auth: { type: "api_key", credential: "credential/openai/api_key" },
+    };
+    const err = await preflightError(resolved());
+    expect(err?.reason).toBe("provider_mismatch");
+  });
+
+  test("the vellum managed connection serves managed-routable providers when logged in", async () => {
+    connectionsByName = {
+      vellum: {
+        name: "vellum",
+        provider: "vellum",
+        auth: { type: "platform" },
+      },
+    };
+    platformLoggedIn = true;
+    expect(
+      await preflightError(resolved({ provider_connection: "vellum" })),
+    ).toBeUndefined();
+
+    platformLoggedIn = false;
+    const err = await preflightError(
+      resolved({ provider_connection: "vellum" }),
+    );
+    expect(err?.reason).toBe("platform_unauthenticated");
+  });
+
+  test("the vellum managed connection rejects non-managed-routable providers", async () => {
+    connectionsByName = {
+      vellum: {
+        name: "vellum",
+        provider: "vellum",
+        auth: { type: "platform" },
+      },
+    };
+    platformLoggedIn = true;
+    const err = await preflightError(
+      resolved({ provider: "openrouter", provider_connection: "vellum" }),
+    );
+    expect(err?.reason).toBe("provider_mismatch");
+  });
+
+  test("platform-auth connections require a platform login", async () => {
+    connectionsByName["anthropic-personal"] = {
+      name: "anthropic-personal",
+      provider: "anthropic",
+      auth: { type: "platform" },
+    };
+    const err = await preflightError(resolved());
+    expect(err?.reason).toBe("platform_unauthenticated");
+
+    platformLoggedIn = true;
+    expect(await preflightError(resolved())).toBeUndefined();
+  });
+
+  test("a credential-store outage on platform auth passes silently — never reported as logout", async () => {
+    connectionsByName["anthropic-personal"] = {
+      name: "anthropic-personal",
+      provider: "anthropic",
+      auth: { type: "platform" },
+    };
+    cesUnreachable = true;
+    expect(await preflightError(resolved())).toBeUndefined();
+  });
+
+  test("keyless and unknown auth types pass through to dispatch", async () => {
+    connectionsByName["anthropic-personal"] = {
+      name: "anthropic-personal",
+      provider: "anthropic",
+      auth: { type: "none" },
+    };
+    expect(await preflightError(resolved())).toBeUndefined();
+  });
+});