@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/cli/commands/oauth/request.ts

@@ -2,7 +2,11 @@ import { readFileSync, writeFileSync } from "node:fs";
 
 import type { Command } from "commander";
 
-import { cliIpcCall, exitFromIpcResult } from "../../../ipc/cli-client.js";
+import { exitFromIpcResult } from "../../../ipc/cli-client.js";
+import {
+  findContentTypeHeader,
+  parseRequestBodyData,
+} from "../../../util/oauth-request-body.js";
 import { readStdinSync } from "../../../util/read-stdin.js";
 import { subcommand } from "../../lib/cli-command-help.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
@@ -33,18 +37,6 @@ function parseHeader(raw: string): [string, string] {
   return [raw.slice(0, idx).trim(), raw.slice(idx + 1).trim()];
 }
 
-/**
- * Attempt to JSON-parse a string. Returns the parsed value on success,
- * or the original string on failure.
- */
-function tryJsonParse(raw: string): unknown {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return raw;
-  }
-}
-
 /**
  * Read body data from the `-d` flag value. Supports:
  * - `@-` reads stdin
@@ -54,20 +46,28 @@ function tryJsonParse(raw: string): unknown {
  * File/stdin reading must happen on the CLI side (not the daemon)
  * since stdin is attached to the CLI process and file paths are
  * relative to the user's cwd.
+ *
+ * A non-JSON `Content-Type` keeps the payload as the exact string the caller
+ * gave, so multipart, XML, and form-encoded bodies reach the provider
+ * unchanged. Files are read as UTF-8 text, so a body that is not valid UTF-8
+ * (a raw image, an archive) cannot travel through this flag.
  */
-function readBodyData(data: string): unknown {
+export function readBodyData(
+  data: string,
+  headers: Record<string, string>,
+): unknown {
+  const contentType = findContentTypeHeader(headers);
+
   if (data === "@-") {
-    const raw = readStdinSync();
-    return tryJsonParse(raw);
+    return parseRequestBodyData(readStdinSync(), contentType);
   }
 
   if (data.startsWith("@")) {
     const filePath = data.slice(1);
-    const raw = readFileSync(filePath, "utf-8");
-    return tryJsonParse(raw);
+    return parseRequestBodyData(readFileSync(filePath, "utf-8"), contentType);
   }
 
-  return tryJsonParse(data);
+  return parseRequestBodyData(data, contentType);
 }
 
 // ---------------------------------------------------------------------------
@@ -90,7 +90,7 @@ export function registerRequestCommand(oauth: Command): void {
     )
     .option(
       "-d, --data <data>",
-      "Request body: inline JSON, @filename, or @- for stdin",
+      "Request body: inline JSON, @filename, or @- for stdin. Sent raw when Content-Type is not JSON",
     )
     .option("-G, --get", "Force GET; body data becomes query params")
     .option("-I, --head", "Send a HEAD request")
@@ -172,10 +172,9 @@ export function registerRequestCommand(oauth: Command): void {
           // Read body data on the CLI side (file/stdin reading must happen here)
           let parsedData: unknown;
           if (opts.data !== undefined) {
-            parsedData = readBodyData(opts.data);
+            parsedData = readBodyData(opts.data, parsedHeaders);
           }
 
-          // Build IPC request body
           const body: Record<string, unknown> = {
             provider: opts.provider,
             url,
@@ -202,22 +201,36 @@ export function registerRequestCommand(oauth: Command): void {
             body.client_id = opts.clientId;
           }
 
-          const r = await cliIpcCall<{
+          // Run the route handler in this process so Gmail-sized fetch and
+          // JSON parse stay off the assistant event loop.
+          const { handleRequest } =
+            await import("../../../runtime/routes/oauth-commands-routes.js");
+          const { RouteError } =
+            await import("../../../runtime/routes/errors.js");
+
+          let result: {
             ok: boolean;
             status: number;
             headers: Record<string, string>;
             body: unknown;
+            bodyEncoding?: "base64";
             hint?: string;
             account?: string | null;
             accountWarning?: string;
-          }>("oauth_request", { body });
-
-          if (!r.ok) {
-            return exitFromIpcResult(r);
+          };
+          try {
+            result = (await handleRequest({ body })) as typeof result;
+          } catch (err) {
+            if (err instanceof RouteError) {
+              return exitFromIpcResult({
+                ok: false,
+                error: err.message,
+                statusCode: err.statusCode,
+              });
+            }
+            throw err;
           }
 
-          const result = r.result!;
-
           // Non-2xx exit code
           if (result.status < 200 || result.status >= 300) {
             process.exitCode = 1;
@@ -251,20 +264,23 @@ export function registerRequestCommand(oauth: Command): void {
             writeInfo(`<`);
           }
 
-          // Body output (skip for null bodies — HEAD requests, 204, etc.)
-          if (result.body != null) {
-            const bodyStr =
-              typeof result.body === "string"
-                ? result.body
-                : JSON.stringify(result.body, null, 2);
-
-            if (opts.output) {
-              writeFileSync(opts.output, bodyStr, "utf-8");
-            } else {
-              process.stdout.write(bodyStr + "\n");
+          // Body output (skip for null bodies: HEAD requests, 204, etc.)
+          if (result.body != null || result.bodyEncoding === "base64") {
+            const { materializeOAuthRequestOutput } =
+              await import("../../../oauth/connection.js");
+            const output = materializeOAuthRequestOutput(result);
+            if (output) {
+              if (opts.output) {
+                writeFileSync(opts.output, output.bytes);
+              } else {
+                process.stdout.write(output.bytes);
+                if (!output.isBinary) {
+                  process.stdout.write("\n");
+                }
+              }
             }
           } else if (opts.output) {
-            writeFileSync(opts.output, "", "utf-8");
+            writeFileSync(opts.output, Buffer.alloc(0));
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);

package/src/cli/lib/bundled-marketplace.json

@@ -214,6 +214,19 @@
       "license": "MIT",
       "icon": "📣"
     },
+    {
+      "name": "imessage",
+      "source": {
+        "source": "github",
+        "repo": "vellum-ai/imessage",
+        "ref": "069a8375e2a6ed069550866114a653218864bc91"
+      },
+      "description": "iMessage and SMS channel for the Vellum assistant, backed by a Photon line.",
+      "category": "productivity",
+      "homepage": "https://github.com/vellum-ai/imessage",
+      "license": "MIT",
+      "icon": "📲"
+    },
     {
       "name": "kitchen-companion",
       "source": {
@@ -297,7 +310,7 @@
       "source": {
         "source": "github",
         "repo": "vellum-ai/natural",
-        "ref": "3cfc8c97c14df311fc64992ab8b172c1b2d64eb0"
+        "ref": "e71880d144337d1b8b6d3e65ab98006b7d015ef6"
       },
       "description": "Hosted MCP access to Natural payment operations for Vellum assistants.",
       "category": "finance",

package/src/cli/lib/open-browser.test.ts

@@ -0,0 +1,67 @@
+import type { ChildProcess, spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { openInHostBrowser } from "./open-browser.js";
+
+describe("openInHostBrowser", () => {
+  test("launches the default browser directly on macOS", () => {
+    const calls: Array<{
+      command: string;
+      args: readonly string[];
+      options: unknown;
+    }> = [];
+    let unrefCalled = false;
+    const child = new EventEmitter() as ChildProcess;
+    child.unref = () => {
+      unrefCalled = true;
+      return child;
+    };
+    const spawnImpl = ((
+      command: string,
+      args: readonly string[],
+      options: unknown,
+    ) => {
+      calls.push({ command, args, options });
+      return child;
+    }) as typeof spawn;
+
+    openInHostBrowser("https://example.com/auth", {
+      platform: "darwin",
+      spawnImpl,
+    });
+
+    expect(calls).toEqual([
+      {
+        command: "open",
+        args: ["https://example.com/auth"],
+        options: { detached: true, stdio: "ignore" },
+      },
+    ]);
+    expect(unrefCalled).toBe(true);
+  });
+
+  test("emits a host-client signal on Windows", () => {
+    const workspaceDir = mkdtempSync(join(tmpdir(), "open-browser-test-"));
+    try {
+      openInHostBrowser("https://example.com/auth", {
+        platform: "win32",
+        workspaceDir,
+      });
+
+      expect(
+        JSON.parse(
+          readFileSync(join(workspaceDir, "signals", "emit-event"), "utf8"),
+        ),
+      ).toEqual({
+        type: "open_url",
+        url: "https://example.com/auth",
+      });
+    } finally {
+      rmSync(workspaceDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/cli/lib/open-browser.ts

@@ -1,9 +1,8 @@
 /**
  * CLI-side helper that opens a URL on the user's host machine.
  *
- * Writes an `open_url` event to the `signals/emit-event` file so that the
- * assistant's ConfigWatcher picks it up and publishes it to connected
- * clients (e.g. the Swift macOS app) via the assistant event hub.
+ * On macOS, launches the default browser directly. Other platforms write an
+ * `open_url` event so a connected host client can open the URL.
  *
  * CLI-initiated emit — no conversation context available, so the inner
  * message has no `conversationId`. That's fine: `OpenUrlEventSchema`
@@ -13,6 +12,7 @@
  * Uses only `node:` imports so it's safe for `ipc`-tagged CLI commands.
  */
 
+import { spawn } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -27,9 +27,28 @@ function getWorkspaceDir(): string {
   );
 }
 
-export function openInHostBrowser(url: string): void {
+export function openInHostBrowser(
+  url: string,
+  deps: {
+    platform?: NodeJS.Platform;
+    spawnImpl?: typeof spawn;
+    workspaceDir?: string;
+  } = {},
+): void {
+  if ((deps.platform ?? process.platform) === "darwin") {
+    const child = (deps.spawnImpl ?? spawn)("open", [url], {
+      detached: true,
+      stdio: "ignore",
+    });
+    child.on("error", () => {
+      // The caller prints a fallback URL.
+    });
+    child.unref();
+    return;
+  }
+
   try {
-    const signalsDir = join(getWorkspaceDir(), "signals");
+    const signalsDir = join(deps.workspaceDir ?? getWorkspaceDir(), "signals");
     mkdirSync(signalsDir, { recursive: true });
     writeFileSync(
       join(signalsDir, "emit-event"),

package/src/config/__tests__/profile-materialization.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, mock, test } from "bun:test";
 // kind, so the tests control the row store directly.
 const connectionRows = new Map<string, { name: string; provider: string }>([
   ["anthropic-personal", { name: "anthropic-personal", provider: "anthropic" }],
+  ["local-ollama", { name: "local-ollama", provider: "ollama" }],
 ]);
 mock.module("../../persistence/db-connection.js", () => ({
   getDb: () => ({}),
@@ -36,6 +37,31 @@ const fullDefault = LLMConfigBase.parse({
 });
 
 describe("completeCustomProfile", () => {
+  test("clamps a filled maxTokens to the model's catalog output cap", () => {
+    const completed = completeCustomProfile(fullDefault, {
+      provider: "ollama",
+      model: "llama3.2",
+    });
+    expect(completed.maxTokens).toBe(4096);
+  });
+
+  test("clamps a filled maxTokens for an entry-name provider via its row's kind", () => {
+    const completed = completeCustomProfile(fullDefault, {
+      provider: "local-ollama",
+      model: "llama3.2",
+    });
+    expect(completed.maxTokens).toBe(4096);
+  });
+
+  test("never clamps an explicit maxTokens", () => {
+    const completed = completeCustomProfile(fullDefault, {
+      provider: "ollama",
+      model: "llama3.2",
+      maxTokens: 64000,
+    });
+    expect(completed.maxTokens).toBe(64000);
+  });
+
   test("inherits omitted scalar fields from the default", () => {
     const completed = completeCustomProfile(fullDefault, {
       model: "claude-fable-5",

package/src/config/bundled-skills/phone-calls/references/TROUBLESHOOTING.md

@@ -80,6 +80,12 @@ The system has a 30-second silence timeout. If nobody speaks for 30 seconds duri
 - Verify `services.tts.providers.elevenlabs.voiceId` is set to a valid ElevenLabs voice ID
 - Ask for the desired voice style again and try a different voice selection
 
+## Inbound call asks for a name or says "I don't recognize this number"
+
+This is the Phone channel trust floor, not a Twilio or webhook failure. The call reached the assistant. Phone defaults to **Verified contacts**, so unknown callers hear that greeting and you get an access request instead of a normal conversation.
+
+Load `twilio-setup` and follow its Channel Trust Floors section. Change **Who can message** on **Channels → Phone**, or verify the caller, rather than retuning ingress.
+
 ## Twilio says "application error" right after answer
 
 - This often means the voice webhook failed or returned invalid TwiML, or the media-stream WebSocket could not connect

package/src/config/bundled-skills/schedule/SKILL.md

@@ -158,7 +158,7 @@ Optionally pass `routing_hints` (a JSON object) to influence routing decisions (
   2. **`interface` fallback** — if `source_channel` is absent (common for guardian/direct users), map the `interface` value to a channel name:
      | `interface` value | Channel name |
      | --- | --- |
-     | `macos`, `ios` | `vellum` |
+     | `macos`, `windows`, `ios` | `vellum` |
      | `telegram` | `telegram` |
      | `slack` | `slack` |
      | `cli` | _(omit — no routable channel)_ |

package/src/config/feature-flag-registry.json

@@ -92,6 +92,14 @@
       "description": "Enable the Quick Input popover on right-click of the menu bar icon",
       "defaultEnabled": false
     },
+    {
+      "id": "teach",
+      "scope": "client",
+      "key": "teach",
+      "label": "Teach",
+      "description": "Offer Teach, the session that reads the user's screen while they narrate what they are doing. Gates the companion surface's Teach control and the toggleWatch command that starts a session; evaluated in the app's window and read again in the Electron main process, which pushes it to the floating surface",
+      "defaultEnabled": false
+    },
     {
       "id": "expand-completed-steps",
       "scope": "client",
@@ -100,6 +108,14 @@
       "description": "Auto-expand completed tool call step groups instead of showing them collapsed",
       "defaultEnabled": false
     },
+    {
+      "id": "inline-assistant-intermediates",
+      "scope": "client",
+      "key": "inline-assistant-intermediates",
+      "label": "Inline Assistant Intermediates",
+      "description": "Render a completed response's intermediate activity inline at full size instead of collapsing it behind the Earlier activity disclosure",
+      "defaultEnabled": false
+    },
     {
       "id": "backward-releases",
       "scope": "assistant",
@@ -145,7 +161,7 @@
       "scope": "client",
       "key": "internal-thread-actions",
       "label": "Internal Thread Actions",
-      "description": "Show the internal thread affordances: 'Fork from here' on messages, 'Fork Conversation', 'Analyze Conversation', and 'Copy conversation ID' in the thread menu, plus the LLM inspector surfaces. The flag is the sole gate: any session that enables it gets the affordances, including local sessions with no platform identity.",
+      "description": "Show the internal thread affordances: 'Fork from here' and 'Summarize up to here' on messages, 'Fork Conversation', 'Analyze Conversation', and 'Copy conversation ID' in the thread menu, plus the LLM inspector surfaces. The flag is the sole gate: any session that enables it gets the affordances, including local sessions with no platform identity.",
       "defaultEnabled": false
     },
     {

package/src/config/profile-materialization.ts

@@ -1,7 +1,9 @@
 import { getDb } from "../persistence/db-connection.js";
+import { catalogProviderForProfile } from "../providers/connection-resolution.js";
 import { ROUTING_IDENTITY_PROVIDERS } from "../providers/inference/auth.js";
 import { getConnection } from "../providers/inference/connections.js";
 import {
+  catalogMaxOutputTokens,
   getCatalogProviderForModel,
   isModelInCatalog,
 } from "../providers/model-catalog.js";
@@ -100,6 +102,33 @@ export function completeCustomProfile(
     }
   }
 
+  // A FILLED maxTokens expresses no user preference, so it is clamped to the
+  // model's catalog output cap — an over-cap fill (e.g. 64000 onto a
+  // 4096-cap model) would make every request fail upstream. Runs after the
+  // provider implication above so the cap is read from the provider the
+  // profile actually dispatches with. An explicit profile value is never
+  // touched, and models the catalog does not know keep the default (the
+  // save-time probe covers those). Mirrors `clampMaxTokensToModelCap` for
+  // the code-owned default profiles.
+  if (
+    profile.maxTokens === undefined &&
+    completed.maxTokens !== undefined &&
+    completed.provider !== undefined &&
+    completed.model !== undefined
+  ) {
+    const catalogProvider = catalogProviderForProfile(
+      completed.provider,
+      completed.model,
+    );
+    const cap =
+      catalogProvider !== null
+        ? catalogMaxOutputTokens(catalogProvider, completed.model)
+        : undefined;
+    if (cap !== undefined && completed.maxTokens > cap) {
+      completed.maxTokens = cap;
+    }
+  }
+
   // Completion never stamps a `provider_connection`; an inherited binding
   // would only re-introduce the collapsed field on disk. The default's
   // explicit binding is instead inherited IN the provider value, the

package/src/config/sanitize-for-transfer.ts

@@ -1,3 +1,9 @@
+import {
+  INGRESS_ASSISTANT_ID_KEY,
+  INGRESS_LAST_TUNNEL_KEY,
+  INGRESS_PAIRING_TUNNEL_KEY,
+} from "@vellumai/service-contracts/ingress";
+
 /**
  * Strips environment-specific fields from config JSON before transferring
  * between local and platform environments (teleport/restore).
@@ -6,6 +12,9 @@
  * - `ingress.publicBaseUrl` → set to `""`
  * - `ingress.enabled` → deleted
  * - `ingress.publicBaseUrlManagedBy` → deleted
+ * - `ingress.lastTunnel` → deleted
+ * - `ingress.pairingTunnel` → deleted
+ * - `ingress.assistantId` → deleted
  * - `telegram.registeredWebhookUrl` → deleted
  * - `daemon` → deleted entirely
  * - `skills.load.extraDirs` → set to `[]`
@@ -44,6 +53,13 @@ export function sanitizeConfigForTransfer(configJson: string): string {
     ingress.publicBaseUrl = "";
     delete ingress.enabled;
     delete ingress.publicBaseUrlManagedBy;
+    // The remembered tunnels and the assistant they fronted belong to the
+    // source host; carrying them over makes tunnel-status UIs name the old
+    // deployment, and the pairing record would have the destination advertise
+    // an address on the source's tailnet.
+    delete ingress[INGRESS_LAST_TUNNEL_KEY];
+    delete ingress[INGRESS_PAIRING_TUNNEL_KEY];
+    delete ingress[INGRESS_ASSISTANT_ID_KEY];
   }
 
   // Strip the recorded Telegram webhook URL. It records where *this*

package/src/config/schemas/llm.ts

@@ -604,6 +604,13 @@ export const ProfileEntry = LLMConfigFragment.extend({
    * not yet backfilled by the boot-time migration.
    */
   provider_connection: z.string().min(1).optional(),
+  /**
+   * The profile was deliberately created for a model the catalog does not
+   * list (the write routes' allowUnlisted escape hatch). Stamped at write
+   * time so listings do not flag the row as misconfigured on every read;
+   * a model the checks can vouch for never needs it.
+   */
+  allowUnlisted: z.boolean().optional(),
   /**
    * Absent means active. `.nullable()` matches `label` so the PUT route's
    * "send `null` to clear" sentinel works for status too — a managed

package/src/config/schemas/services.ts

@@ -76,6 +76,9 @@ const WebSearchServiceSchema = z.object({
   provider: z
     .enum(VALID_WEB_SEARCH_PROVIDERS)
     .default("inference-provider-native"),
+  // Origin for providers that support a custom API base (e.g. fastCRW).
+  // Empty / omitted uses the provider's cloud default.
+  apiBase: z.string().optional(),
 });
 
 /**
@@ -88,6 +91,9 @@ const WebFetchServiceSchema = z.object({
   // `firecrawl`) scrape via their hosted API and reuse the same stored key as
   // their web-search counterpart.
   provider: z.enum(VALID_WEB_FETCH_PROVIDERS).default("default"),
+  // Origin for providers that support a custom API base (e.g. fastCRW).
+  // Empty / omitted uses the provider's cloud default.
+  apiBase: z.string().optional(),
 });
 
 const GoogleOAuthServiceSchema = BaseServiceSchema.extend({

package/src/context/outbound-sanitize.ts

@@ -26,6 +26,12 @@ const AX_TREE_PLACEHOLDER = "<ax_tree_omitted />";
  * prematurely when the user happens to be viewing XML/HTML source that
  * contains the closing tag.  The escaped content does not need to be
  * unescaped because compaction replaces the entire block with a placeholder.
+ *
+ * Deliberately narrower than `escapeTagBoundaries` in
+ * `security/untrusted-content.ts`, which is the general defense for fencing
+ * untrusted text: this one leaves the opening tag intact because
+ * {@link AX_TREE_PATTERN} needs it to find whole blocks. Do not fold the two
+ * together.
  */
 export function escapeAxTreeContent(content: string): string {
   return content.replace(/<\/ax-tree>/gi, "&lt;/ax-tree&gt;");

package/src/daemon/__tests__/lifecycle-watch-timeline-sweep.test.ts

@@ -0,0 +1,98 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, mock, test } from "bun:test";
+
+/**
+ * The watch-timeline sweep's startup contract.
+ *
+ * `drainOrphanedWatchTimelineEntries` is the recovery path for a purge that
+ * did not happen, and the rows it reclaims hold narration, AX trees, and
+ * screenshots of the user's screen. Database maintenance runs it on a periodic
+ * cadence from the memory plugin's jobs worker, so an install with that plugin
+ * disabled or `memory.enabled: false` reaches it never. Daemon startup runs it
+ * on every install and closes that gap.
+ *
+ * Two properties carry the contract, and each is checked the way it can be:
+ *
+ *  1. lifecycle calls the sweep on its DB-ready startup path, after migrations
+ *     have settled. Mounting the full lifecycle import graph to observe a real
+ *     boot is disproportionately heavy, so this is a source guard over the call
+ *     site.
+ *  2. a throwing sweep does not abort startup. The wiring below mirrors the
+ *     lifecycle call site verbatim.
+ */
+
+const LIFECYCLE_PATH = join(import.meta.dir, "..", "lifecycle.ts");
+
+describe("lifecycle watch-timeline sweep wiring", () => {
+  test("lifecycle sweeps orphaned entries on the DB-ready startup path", () => {
+    const source = readFileSync(LIFECYCLE_PATH, "utf8");
+
+    const sweepIndex = source.indexOf("drainOrphanedWatchTimelineEntries()");
+    expect(sweepIndex).toBeGreaterThan(-1);
+
+    // The drain yields between pages, so the call has to be awaited. Without
+    // the await the count is a pending promise, which compares false against
+    // zero, and the pass reports nothing swept however much it removed.
+    expect(source).toContain("await drainOrphanedWatchTimelineEntries()");
+
+    // `startRuntimeHttpServerBackgroundSweeps()` is the point where lifecycle
+    // has established that migrations settled, so a call after it runs against
+    // a database whose tables exist.
+    const migrationsSettledIndex = source.indexOf(
+      "startRuntimeHttpServerBackgroundSweeps();",
+    );
+    expect(migrationsSettledIndex).toBeGreaterThan(-1);
+    expect(sweepIndex).toBeGreaterThan(migrationsSettledIndex);
+
+    // The call sits under a `dbReady` guard, so a boot whose DB never opened
+    // does not reach it.
+    const guardIndex = source.lastIndexOf("if (dbReady) {", sweepIndex);
+    expect(guardIndex).toBeGreaterThan(migrationsSettledIndex);
+  });
+
+  test("invokes the sweep once and logs only when it reclaimed rows", () => {
+    const sweep = mock(() => 0);
+
+    const quiet = runStartupSweepWiring(sweep);
+    expect(sweep).toHaveBeenCalledTimes(1);
+    expect(quiet.logged).toBe(false);
+    expect(quiet.reachedNextStep).toBe(true);
+
+    const noisy = runStartupSweepWiring(mock(() => 3));
+    expect(noisy.logged).toBe(true);
+    expect(noisy.reachedNextStep).toBe(true);
+  });
+
+  test("a throwing sweep does NOT abort startup", () => {
+    const sweep = mock(() => {
+      throw new Error("sweep exploded");
+    });
+
+    const { reachedNextStep, logged } = runStartupSweepWiring(sweep);
+
+    expect(sweep).toHaveBeenCalledTimes(1);
+    expect(logged).toBe(false);
+    expect(reachedNextStep).toBe(true);
+  });
+});
+
+/**
+ * Replicates the lifecycle startup wiring: sweep, log only a non-zero count,
+ * swallow any throw, then continue to the next startup step.
+ */
+function runStartupSweepWiring(sweep: () => number): {
+  reachedNextStep: boolean;
+  logged: boolean;
+} {
+  let logged = false;
+  try {
+    const sweptWatchEntries = sweep();
+    if (sweptWatchEntries > 0) {
+      logged = true;
+    }
+  } catch {
+    // Startup must never block on a subsystem failure.
+  }
+  return { reachedNextStep: true, logged };
+}