@vellumai/assistant 0.8.0 → 0.8.2

package/src/daemon/host-browser-proxy.ts

@@ -1,10 +1,10 @@
 import { v4 as uuid } from "uuid";
 
-import type { InterfaceId } from "../channels/types.js";
 import {
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
+import { enforceSameActorOrErrorResult } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -24,11 +24,49 @@ export type HostBrowserInput = DistributiveOmit<
 
 const log = getLogger("host-browser-proxy");
 
-/** Interface priority order for host_browser: Chrome Extension first, macOS SSE bridge second. */
-const HOST_BROWSER_INTERFACE_PREFERENCE: InterfaceId[] = [
-  "chrome-extension",
-  "macos",
-];
+/**
+ * Pick the host_browser-capable client to dispatch to.
+ *
+ * When `targetClientId` is supplied, the client with that id is looked
+ * up directly in the `host_browser`-capable roster. The same-actor check
+ * in `request()` still runs on the returned client when
+ * `sourceActorPrincipalId` is present.
+ *
+ * When `sourceActorPrincipalId` is supplied (and no explicit target),
+ * candidate clients are filtered down to those owned by the same actor.
+ * Returns `undefined` when no same-actor client is connected; the
+ * caller surfaces this as the existing "no active extension connection"
+ * rejection.
+ *
+ * When neither is supplied (legacy callers without a resolved actor
+ * identity), falls through to the most-recently-active host_browser
+ * client so the registry singleton continues to work for single-client
+ * setups.
+ *
+ * Within each branch, ties are broken by `lastActiveAt` descending —
+ * the natural order returned by `listClientsByCapability`. Callers that
+ * need a specific transport (e.g. Chrome Extension's `chrome.debugger`
+ * over the macOS CDP bridge) must pass `targetClientId` explicitly via
+ * the LLM-facing param added in #30066.
+ */
+function resolveTargetClient(
+  sourceActorPrincipalId: string | undefined,
+  targetClientId?: string,
+) {
+  if (targetClientId != null) {
+    const clients = assistantEventHub.listClientsByCapability("host_browser");
+    return clients.find((c) => c.clientId === targetClientId);
+  }
+
+  const candidates =
+    assistantEventHub.listClientsByCapability("host_browser");
+  if (sourceActorPrincipalId == null) {
+    return candidates[0];
+  }
+  return candidates.find(
+    (c) => c.actorPrincipalId === sourceActorPrincipalId,
+  );
+}
 
 export class HostBrowserProxy {
   private static _instance: HostBrowserProxy | null = null;
@@ -67,10 +105,7 @@ export class HostBrowserProxy {
    */
   isAvailable(): boolean {
     return (
-      assistantEventHub.getPreferredClientByCapability(
-        "host_browser",
-        HOST_BROWSER_INTERFACE_PREFERENCE,
-      ) != null
+      assistantEventHub.getMostRecentClientByCapability("host_browser") != null
     );
   }
 
@@ -84,15 +119,64 @@ export class HostBrowserProxy {
     return assistantEventHub.listClientsByInterface("chrome-extension").length > 0;
   }
 
+  /**
+   * Send a host_browser request to the connected extension/macOS bridge.
+   *
+   * When `targetClientId` is supplied, the proxy dispatches to that specific
+   * client (subject to the `host_browser` capability check and the same-actor
+   * gate below). This mirrors the `target_client_id` pattern on `host_bash`,
+   * `host_file_*`, and `host_cu`.
+   *
+   * When `sourceActorPrincipalId` is supplied, the proxy refuses to dispatch
+   * to a client owned by a different actor — same-user enforcement is the
+   * authoritative gate against routing one actor's CDP request onto another
+   * actor's connected extension. The resolved target's `clientId` and
+   * `actorPrincipalId` are then persisted alongside the pending interaction
+   * so that the result-route's same-actor check can verify the submitting
+   * client at result time.
+   *
+   * When `sourceActorPrincipalId` is undefined (legacy/internal flows
+   * with no resolved actor identity), falls back to the most-recently-
+   * active host_browser client without an actor filter so the registry
+   * singleton continues to work for single-client setups.
+   */
   request(
     input: HostBrowserInput,
     conversationId: string,
     signal?: AbortSignal,
+    sourceActorPrincipalId?: string,
+    targetClientId?: string,
   ): Promise<ToolExecutionResult> {
     if (signal?.aborted) {
       return Promise.resolve({ content: "Aborted", isError: true });
     }
 
+    // Resolve the target client up front so we can persist the actor binding
+    // alongside the pending interaction registration. Same shape as
+    // host-cu-proxy: the result-route same-actor check compares the
+    // submitting client's actor against this captured value.
+    const preferredClient = resolveTargetClient(sourceActorPrincipalId, targetClientId);
+
+    // Same-user enforcement: when the caller's actor is known, refuse to
+    // dispatch to a client owned by a different actor. This covers the
+    // cross-client exposure case where a web/iOS turn for actor A would
+    // otherwise auto-resolve to actor B's connected extension.
+    if (
+      sourceActorPrincipalId != null &&
+      preferredClient != null &&
+      preferredClient.actorPrincipalId !== sourceActorPrincipalId
+    ) {
+      const rejection = enforceSameActorOrErrorResult({
+        hub: assistantEventHub,
+        sourceActorPrincipalId,
+        targetClientId: preferredClient.clientId,
+        op: "host_browser",
+      });
+      if (rejection) return Promise.resolve(rejection);
+    }
+
+    const resolvedClientId = preferredClient?.clientId;
+    const targetActorPrincipalId = preferredClient?.actorPrincipalId;
     const requestId = uuid();
 
     return new Promise<ToolExecutionResult>((resolve, reject) => {
@@ -135,6 +219,8 @@ export class HostBrowserProxy {
       pendingInteractions.register(requestId, {
         conversationId,
         kind: "host_browser",
+        targetClientId: resolvedClientId,
+        targetActorPrincipalId,
         rpcResolve: resolve as (v: unknown) => void,
         rpcReject: reject,
         timer,
@@ -142,10 +228,6 @@ export class HostBrowserProxy {
       });
 
       try {
-        const preferredClient = assistantEventHub.getPreferredClientByCapability(
-          "host_browser",
-          HOST_BROWSER_INTERFACE_PREFERENCE,
-        );
         if (!preferredClient) {
           pendingInteractions.resolve(requestId);
           reject(
@@ -172,27 +254,6 @@ export class HostBrowserProxy {
     });
   }
 
-  /**
-   * Process a client result and resolve the RPC. Called by route handlers.
-   */
-  resolveResult(
-    requestId: string,
-    response: { content: string; isError: boolean },
-  ): void {
-    const interaction = pendingInteractions.resolve(requestId);
-    if (!interaction?.rpcResolve) {
-      log.debug(
-        { requestId },
-        "Ignoring host_browser_result for unknown or already-resolved request",
-      );
-      return;
-    }
-    interaction.rpcResolve({
-      content: response.content,
-      isError: response.isError,
-    });
-  }
-
   dispose(): void {
     for (const entry of pendingInteractions.getByKind("host_browser")) {
       pendingInteractions.resolve(entry.requestId);

package/src/daemon/host-proxy-base.ts

@@ -141,8 +141,10 @@ export abstract class HostProxyBase<TRequest, TResultPayload> {
     signal?: AbortSignal,
     extraFields?: Record<string, unknown>,
     targetClientId?: string,
+    timeoutMsOverride?: number,
   ): Promise<TResultPayload> {
     const requestId = uuid();
+    const effectiveTimeoutMs = timeoutMsOverride ?? this.timeoutMs;
 
     return new Promise<TResultPayload>((resolve, reject) => {
       // Declared up-front so onAbort can close over a stable reference once
@@ -158,7 +160,7 @@ export abstract class HostProxyBase<TRequest, TResultPayload> {
           "Host proxy request timed out",
         );
         reject(new HostProxyRequestError("timeout", "timeout"));
-      }, this.timeoutMs);
+      }, effectiveTimeoutMs);
 
       if (signal) {
         const onAbort = () => {
@@ -204,10 +206,20 @@ export abstract class HostProxyBase<TRequest, TResultPayload> {
       // (HostCuProxy bypasses dispatchRequest entirely with its own inline
       //  request method that registers directly, which is why CU works
       //  without this base-level fix.)
+      // Snapshot the target's actorPrincipalId at registration time so the
+      // result-route same-actor check has a stable value to compare against —
+      // the target client's SSE subscription may briefly disconnect between
+      // dispatch and result submission, which would make a live hub lookup
+      // falsely 403 a legitimate result.
+      const targetActorPrincipalId =
+        targetClientId != null
+          ? assistantEventHub.getActorPrincipalIdForClient(targetClientId)
+          : undefined;
       pendingInteractions.register(requestId, {
         conversationId,
         kind: this.resultPendingKind,
         ...(targetClientId != null ? { targetClientId } : {}),
+        ...(targetActorPrincipalId != null ? { targetActorPrincipalId } : {}),
       });
 
       try {

package/src/daemon/host-proxy-preactivation.ts

@@ -28,6 +28,7 @@
 
 import type { HostProxyCapability, InterfaceId } from "../channels/types.js";
 import { supportsHostProxy } from "../channels/types.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 
 /**
  * Subset of Conversation/ProcessConversationContext that
@@ -60,6 +61,29 @@ export const HOST_PROXY_SKILL_PREACTIVATIONS: ReadonlyArray<{
   { capability: "host_app_control", skillId: "app-control" },
 ];
 
+/**
+ * Returns true when a host-proxy for the given capability should be attached
+ * (instantiated and preactivated) for the current turn. Two cases qualify:
+ *
+ *  1. The source interface natively supports the capability (e.g. macOS → host_cu).
+ *  2. The source interface doesn't support the capability natively but at least
+ *     one connected client does — cross-client routing. `chrome-extension` is
+ *     excluded as a security boundary: it is its own executor context and cannot
+ *     broker cross-client routing to a macOS client.
+ *
+ * This is the single source of truth for both preactivation and proxy
+ * instantiation, so the two decisions stay in sync.
+ */
+export function shouldAttachHostProxyForCapability(
+  capability: HostProxyCapability,
+  sourceInterface: InterfaceId | undefined,
+): boolean {
+  if (!sourceInterface) return false;
+  if (supportsHostProxy(sourceInterface, capability)) return true;
+  if (sourceInterface === "chrome-extension") return false;
+  return assistantEventHub.listClientsByCapability(capability).length > 0;
+}
+
 /**
  * Preactivate every host-proxy-backed skill that the given source interface
  * supports. No-op when `sourceInterface` is undefined.
@@ -75,7 +99,7 @@ export function preactivateHostProxySkills(
 ): void {
   if (!sourceInterface) return;
   for (const { capability, skillId } of HOST_PROXY_SKILL_PREACTIVATIONS) {
-    if (supportsHostProxy(sourceInterface, capability)) {
+    if (shouldAttachHostProxyForCapability(capability, sourceInterface)) {
       conversation.addPreactivatedSkillId(skillId);
     }
   }

package/src/daemon/identity-helpers.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 import { getWorkspacePromptPath } from "../util/platform.js";
 
@@ -14,3 +15,21 @@ export function getAssistantName(): string | null {
     return null;
   }
 }
+
+/**
+ * Read the guardian's display name from `users/default.md`. We look for the
+ * markdown-bold "Name" label (matching the IDENTITY.md convention) and fall
+ * back to `null` on any miss; callers substitute a generic label.
+ */
+export function resolveUserName(workspaceDir: string): string | null {
+  try {
+    const content = readFileSync(
+      join(workspaceDir, "users", "default.md"),
+      "utf-8",
+    );
+    const match = content.match(/\*\*Name:\*\*\s*(.+)/);
+    return match?.[1]?.trim() || null;
+  } catch {
+    return null;
+  }
+}

package/src/daemon/lifecycle.ts

@@ -20,6 +20,7 @@ import type { AssistantConfig } from "../config/schema.js";
 import { seedInferenceProfiles } from "../config/seed-inference-profiles.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { createCesClient } from "../credential-execution/client.js";
+import { refreshManagedConnectionCache } from "../credential-execution/managed-catalog.js";
 import {
   type CesProcessManager,
   CesUnavailableError,
@@ -31,10 +32,6 @@ import {
 } from "../credential-execution/startup-timeout.js";
 import { FilingService } from "../filing/filing-service.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
-import {
-  type FeedSchedulerHandle,
-  startFeedScheduler,
-} from "../home/feed-scheduler.js";
 import { backfillRelationshipStateIfMissing } from "../home/relationship-state-writer.js";
 import { closeSentry, initSentry, setSentryDeviceId } from "../instrument.js";
 import { getMcpServerManager } from "../mcp/manager.js";
@@ -44,6 +41,7 @@ import {
 } from "../memory/attachments-store.js";
 import { expireAllPendingCanonicalRequests } from "../memory/canonical-guardian-store.js";
 import { deleteMessageById, getMessages } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { selectEmbeddingBackend } from "../memory/embedding-backend.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
@@ -57,10 +55,12 @@ import {
 } from "../notifications/emit-signal.js";
 import { backfillManualTokenConnections } from "../oauth/manual-token-connection.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
+import { installPluginRuntime } from "../plugins/external-api.js";
 import { loadUserPlugins } from "../plugins/user-loader.js";
 import { backfillGuardIfNeeded } from "../proactive-artifact/index.js";
 import { ensurePromptFiles } from "../prompts/system-prompt.js";
-import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
+import { runProviderConnectionsBackfill } from "../providers/inference/backfill.js";
+import { resolveManagedProxyContext } from "../providers/platform-proxy/context.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import {
   initAuthSigningKey,
@@ -76,7 +76,10 @@ import {
   setCesClient,
   setCesReconnect,
 } from "../security/secure-keys.js";
-import { UsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
+import {
+  setUsageTelemetryReporter,
+  UsageTelemetryReporter,
+} from "../telemetry/usage-telemetry-reporter.js";
 import { registerBuiltinTtsProviders } from "../tts/providers/register-builtins.js";
 import { getDeviceId } from "../util/device-id.js";
 import { getLogger, initLogger } from "../util/logger.js";
@@ -116,7 +119,7 @@ import { backfillSlackInjectionTemplates } from "./handlers/config-slack-channel
 import { installAssistantSymlink } from "./install-symlink.js";
 import {
   maybeRebuildMemoryV2Concepts,
-  maybeSeedMemoryV2Skills,
+  rebuildBm25CorpusStatsAndReseedSkills,
 } from "./memory-v2-startup.js";
 import { processMessage } from "./process-message.js";
 import { runProfilerSweep } from "./profiler-run-store.js";
@@ -128,6 +131,7 @@ import {
 import { seedInterfaceFiles } from "./seed-files.js";
 import { DaemonServer } from "./server.js";
 import { installShutdownHandlers } from "./shutdown-handlers.js";
+import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
 
 const log = getLogger("lifecycle");
 let diskPressureStartupSampleTimer: ReturnType<typeof setTimeout> | null = null;
@@ -327,8 +331,6 @@ export async function runDaemon(): Promise<void> {
       log.warn({ err }, "Background feature flag init failed"),
     );
 
-    maybeSeedMemoryV2Skills(loadConfig());
-
     seedInterfaceFiles();
 
     log.info("Daemon startup: initializing DB");
@@ -370,6 +372,20 @@ export async function runDaemon(): Promise<void> {
       await runWorkspaceMigrations(getWorkspaceDir(), WORKSPACE_MIGRATIONS);
       log.info("Daemon startup: workspace migrations complete");
 
+      // Seed canonical inference provider_connections and backfill any legacy
+      // profiles that pre-date the connection field. Runs after workspace
+      // migrations so migration 076 has already stripped services.inference.mode
+      // before backfill reads config. Idempotent — runs every boot so new
+      // canonicals propagate and manual config.json edits self-heal.
+      try {
+        runProviderConnectionsBackfill(getDb());
+      } catch (err) {
+        log.warn(
+          { err },
+          "provider_connections backfill failed — continuing startup",
+        );
+      }
+
       // Profiler retention sweep — prune completed profiler runs to stay
       // within configured byte-count, run-count, and free-space budgets.
       // Runs on every startup and is safe to call from explicit cleanup routes.
@@ -494,21 +510,41 @@ export async function runDaemon(): Promise<void> {
       }
     } // end if (dbReady)
 
+    // Populate the managed-connection cache so buildIntegrationSection()
+    // can include platform-managed OAuth connections (e.g. Twitter) in the
+    // system prompt's "Connected Services" section from the first turn.
+    // This is an HTTP-only call with no DB dependency, so it runs regardless
+    // of dbReady. A periodic refresh keeps the cache current when users
+    // connect/disconnect managed providers while the assistant is running.
+    void refreshManagedConnectionCache().catch((err) =>
+      log.warn(
+        { err },
+        "Managed connection cache refresh failed — continuing startup",
+      ),
+    );
+    const MANAGED_CONNECTION_REFRESH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+    setInterval(() => {
+      void refreshManagedConnectionCache().catch((err) =>
+        log.warn({ err }, "Periodic managed connection cache refresh failed"),
+      );
+    }, MANAGED_CONNECTION_REFRESH_INTERVAL_MS);
+
     // Merge CLI-provided default config (from VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH)
     // into the workspace config file before profile seeding and the first
     // loadConfig() call so onboarding/platform preferences are visible to the
     // seeder and persisted alongside schema defaults.
     const defaultConfigMerge = mergeDefaultWorkspaceConfig();
 
-    // Seed managed inference profiles into the workspace config. Runs after
-    // workspace migrations and default-config merge, but before loadConfig() so
-    // fresh hatches have profiles on disk before the first config load. Any
-    // profile fields explicitly supplied by the default overlay stay
-    // authoritative for this startup.
+    // Seed inference profiles into the workspace config. Managed Anthropic
+    // profiles are overwritten on every boot so Vellum can push updates.
+    // Off-platform hatches additionally create user profiles + a personal
+    // provider connection for the hatch provider.
     try {
       seedInferenceProfiles({
         preserveProfileNames: defaultConfigMerge.providedLlmProfileNames,
         preserveActiveProfile: defaultConfigMerge.providedLlmActiveProfile,
+        isHatch: defaultConfigMerge.hadOverlay,
+        db: dbReady ? getDb() : undefined,
       });
       log.info("Inference profile seeding complete");
     } catch (err) {
@@ -554,6 +590,7 @@ export async function runDaemon(): Promise<void> {
     let telemetryReporter: UsageTelemetryReporter | null = null;
     if (collectUsageData) {
       telemetryReporter = new UsageTelemetryReporter();
+      setUsageTelemetryReporter(telemetryReporter);
       telemetryReporter.start();
       log.info("Usage telemetry reporter started");
     }
@@ -637,6 +674,12 @@ export async function runDaemon(): Promise<void> {
       });
     }
 
+    // Install the `globalThis.__vellumPluginRuntime` bridge before scanning
+    // for user plugins. Plugins that touch the bridge from their module body
+    // would throw without this — see `plugins/external-api.ts` for the
+    // rationale (compiled-binary module identity).
+    installPluginRuntime();
+
     // Populate the registry with user plugins from `<workspaceDir>/plugins/*`
     // AFTER first-party plugins have already registered via their static
     // side-effect imports. User plugins may fail to load individually; a
@@ -819,22 +862,30 @@ export async function runDaemon(): Promise<void> {
         }
 
         // Build the BM25 corpus stats (per-token document frequencies and
-        // average document length) used by the v2 sparse channel. Without
-        // this, document-side sparse embeddings fall back to legacy TF-only
-        // weighting via the chicken-and-egg guard in
-        // `embed-concept-page.ts`. Fire-and-forget for the same reason as
-        // PKB reconcile — the stats are an optional optimization, never a
-        // boot-blocking dependency.
+        // average document length) used by the v2 sparse channel, then
+        // re-seed v2 skill entries so any skill vectors written during the
+        // cold-start window with the legacy TF encoder get rewritten with
+        // stemmed BM25 vectors. Fire-and-forget for the same reason as PKB
+        // reconcile — the stats and skill reseed are optional optimizations,
+        // never boot-blocking dependencies.
+        void rebuildBm25CorpusStatsAndReseedSkills(config);
+
+        // Validate every concept page's frontmatter against the strict
+        // schema and emit a `warn` per offender. Surfaces schema drift
+        // (unknown keys, type mismatches) at boot time instead of waiting
+        // for the failure to manifest as a silent V2 retrieval no-op when
+        // a bad page first lands in a conversation's top-K. Fire-and-forget
+        // and the sweep itself never throws — defense in depth via the
+        // outer try/catch.
         void (async () => {
           try {
-            const { rebuildConceptPageCorpusStats } =
-              await import("../memory/v2/sparse-bm25.js");
-            await rebuildConceptPageCorpusStats(getWorkspaceDir());
-            log.info("Memory v2 BM25 corpus stats built");
+            const { sweepConceptPageFrontmatter } =
+              await import("../memory/v2/frontmatter-sweep.js");
+            await sweepConceptPageFrontmatter(getWorkspaceDir());
           } catch (err) {
             log.warn(
               { err },
-              "BM25 corpus-stats rebuild failed — sparse channel will fall back to TF-only until next rebuild",
+              "Concept page frontmatter sweep threw — continuing startup",
             );
           }
         })();
@@ -845,20 +896,10 @@ export async function runDaemon(): Promise<void> {
 
       // Seed capability graph nodes (new memory graph system)
       try {
-        const {
-          seedSkillGraphNodes,
-          seedCliGraphNodes,
-          seedUninstalledCatalogSkillMemories,
-        } = await import("../memory/graph/capability-seed.js");
-        seedSkillGraphNodes();
-        maybeSeedMemoryV2Skills(config);
+        const { seedCliGraphNodes } =
+          await import("../memory/graph/capability-seed.js");
+        refreshSkillCapabilityMemories(config);
         await seedCliGraphNodes();
-        void seedUninstalledCatalogSkillMemories().catch((err) =>
-          log.warn(
-            { err },
-            "Uninstalled catalog skill memory seeding failed — continuing",
-          ),
-        );
       } catch (err) {
         log.warn({ err }, "Graph capability seeding failed — continuing");
       }
@@ -958,24 +999,6 @@ export async function runDaemon(): Promise<void> {
           dedupeKey: `watcher:notification:${crypto.randomUUID()}`,
         });
       },
-      (params) => {
-        void emitNotificationSignal({
-          sourceEventName: "watcher.escalation",
-          sourceChannel: "watcher",
-          sourceContextId: `watcher-escalation-${Date.now()}`,
-          attentionHints: {
-            requiresAction: true,
-            urgency: "high",
-            isAsyncBackground: false,
-            visibleInSourceNow: false,
-          },
-          contextPayload: {
-            title: params.title,
-            body: params.body,
-          },
-          dedupeKey: `watcher:escalation:${crypto.randomUUID()}`,
-        });
-      },
       (info) => {
         broadcastMessage({
           type: "schedule_conversation_created",
@@ -986,19 +1009,6 @@ export async function runDaemon(): Promise<void> {
       },
     );
 
-    // Home activity feed scheduler — drives the assistant reflection
-    // loop + the platform Gmail digest. Fire-and-forget; a startup
-    // failure must never block the rest of daemon boot (CLAUDE.md).
-    let feedScheduler: FeedSchedulerHandle | null = null;
-    try {
-      feedScheduler = startFeedScheduler();
-    } catch (err) {
-      log.warn(
-        { err },
-        "Failed to start home feed scheduler — continuing startup",
-      );
-    }
-
     // Start the runtime HTTP server for optional REST API access.
     // Defaults to port 7821.
     let runtimeHttp: RuntimeHttpServer | null = null;
@@ -1338,7 +1348,6 @@ export async function runDaemon(): Promise<void> {
       filing,
       runtimeHttp,
       scheduler,
-      feedScheduler,
       getMemoryWorker: () => bgRefs.memoryWorker,
       getQdrantManager: () => bgRefs.qdrantManager,
       mcpManager,

package/src/daemon/meet-host-supervisor.ts

@@ -14,10 +14,11 @@
  *   - `ensureRunning()` — idempotent. First caller triggers
  *     `child_process.spawn`, subsequent concurrent callers await the
  *     same in-flight promise. Resolves once the child dials
- *     `assistant-skill.sock` and sends a handshake frame (via
- *     `notifyHandshake`) whose reported source-tree hash matches the
- *     shipped manifest's hash. A mismatch kills the spawn and throws
- *     a clear error pointing the user at regenerating the manifest.
+ *     `assistant-skill.sock` and the first `host.registries.register_*`
+ *     frame lands (which calls {@link setActiveConnection}). Source-hash
+ *     drift is not validated on this path — `notifyHandshake` exists for
+ *     a future explicit handshake frame that ships the skill's
+ *     runtime-computed hash, but no production caller invokes it today.
  *
  *   - `reportSessionStarted(id)` / `reportSessionEnded(id)` — mutate
  *     the active-session counter, called by the
@@ -253,10 +254,11 @@ export class MeetHostSupervisor {
   }
 
   /**
-   * Ensure the meet-host child is spawned, the IPC handshake has been
-   * received, and the manifest hash validated. Idempotent: a second
-   * call while the child is already running is a no-op; a second call
-   * during an in-flight spawn awaits the same promise.
+   * Ensure the meet-host child is spawned and the IPC handshake has
+   * been received. Idempotent: a second call while the child is
+   * already running is a no-op; a second call during an in-flight
+   * spawn awaits the same promise. Manifest hash validation is
+   * currently dormant (see {@link notifyHandshake}).
    */
   ensureRunning(): Promise<void> {
     if (this.shuttingDown) {
@@ -278,15 +280,14 @@ export class MeetHostSupervisor {
   }
 
   /**
-   * Called by the IPC route handler when the child sends its
-   * `host.registries.register_tools` / `ready` frame. The supervisor
-   * validates the reported source hash against the shipped manifest
-   * and either resolves or rejects the in-flight `ensureRunning()`
-   * promise accordingly.
-   *
-   * Intentionally public so PR 24's `host.registries.*` route (which
-   * owns the IPC socket) can forward the payload without the
-   * supervisor owning any socket state itself.
+   * Validate a handshake payload's reported source hash against the
+   * shipped manifest and resolve or reject the in-flight
+   * `ensureRunning()` promise accordingly. Currently dormant on the
+   * production path — readiness is signalled by the first
+   * `host.registries.register_*` frame (see {@link setActiveConnection})
+   * which carries no hash. This method is preserved as the integration
+   * point for a future explicit handshake frame whose payload ships the
+   * skill's runtime-computed hash; only tests exercise it today.
    */
   notifyHandshake(payload: MeetHostHandshakePayload): void {
     if (!this.handshakeResolve || !this.handshakeReject) {
@@ -374,8 +375,8 @@ export class MeetHostSupervisor {
     // The first `host.registries.register_*` frame doubles as the
     // readiness signal: it means `register(client)` ran to completion and
     // the IPC socket is healthy. Resolve any in-flight handshake so
-    // `ensureRunning()` unblocks. `notifyHandshake` remains the path for
-    // callers that send a dedicated hash-bearing handshake frame.
+    // `ensureRunning()` unblocks. No source-hash check happens here —
+    // see {@link notifyHandshake} for the dormant validation path.
     this.handshakeResolve?.();
   }