@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/daemon/daemon-skill-host.ts

@@ -1,262 +0,0 @@
-/**
- * `DaemonSkillHost` — in-process concretion of the neutral `SkillHost`
- * interface defined in `@vellumai/skill-host-contracts`.
- *
- * `createDaemonSkillHost(skillId)` returns a plain object whose nine facets
- * (`logger`, `config`, `identity`, `platform`, `providers`, `memory`,
- * `events`, `registries`, `speakers`) delegate to the daemon's existing
- * singleton modules. First-party skills that live in-process receive this
- * host via the bootstrap path instead of reaching into `assistant/` with
- * relative imports.
- *
- * Where a delegate's signature does not line up exactly with the contract
- * — pino's `(meta, msg)` log methods vs the contract's `(msg, meta)`,
- * `getAssistantName()` returning `null` vs the contract's `undefined`,
- * `getProviderKeyAsync()` returning `undefined` vs the contract's `null`,
- * `buildAssistantEvent()` signature differences, etc. — the
- * adaptation happens inside this file so the contract stays narrow and the
- * underlying daemon APIs stay unchanged.
- */
-
-import type {
-  AssistantEvent,
-  AssistantEventCallback,
-  ConfigFacet,
-  EventsFacet,
-  Filter,
-  IdentityFacet,
-  LlmProvidersFacet,
-  Logger,
-  LoggerFacet,
-  MemoryFacet,
-  PlatformFacet,
-  Provider,
-  ProvidersFacet,
-  RegistriesFacet,
-  SecureKeysFacet,
-  ServerMessage,
-  SkillHost,
-  SkillRoute,
-  SkillRouteHandle,
-  SpeakersFacet,
-  StreamingTranscriber,
-  SttProvidersFacet,
-  Subscription,
-  ToolUse,
-  TtsConfig,
-  TtsProvider,
-  TtsProvidersFacet,
-  UserMessage,
-} from "@vellumai/skill-host-contracts";
-
-import { SpeakerIdentityTracker } from "../calls/speaker-identification.js";
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
-import { getConfig, getNestedValue } from "../config/loader.js";
-import type { LLMCallSite } from "../config/schemas/llm.js";
-import { addMessage } from "../persistence/conversation-crud.js";
-import {
-  createTimeout,
-  extractToolUse,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import {
-  listProviderIds as sttListProviderIds,
-  supportsBoundary as sttSupportsBoundary,
-} from "../providers/speech-to-text/provider-catalog.js";
-import { resolveStreamingTranscriber as sttResolveStreamingTranscriber } from "../providers/speech-to-text/resolve.js";
-import { wakeAgentForOpportunity } from "../runtime/agent-wake.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { getDaemonRuntimeMode } from "../runtime/runtime-mode.js";
-import { registerSkillRoute } from "../runtime/skill-route-registry.js";
-import { getProviderKeyAsync } from "../security/secure-keys.js";
-import { registerExternalTools } from "../tools/registry.js";
-import { getTtsProvider } from "../tts/provider-registry.js";
-import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
-import { getLogger } from "../util/logger.js";
-import { getWorkspaceDir, vellumRoot } from "../util/platform.js";
-import { getAssistantName } from "./identity-helpers.js";
-import { registerShutdownHook } from "./shutdown-registry.js";
-
-/**
- * Adapt pino's `(meta, msg)` call shape to the contract's `(msg, meta?)`
- * shape so skills can use `host.logger.get(...).info("msg", { ... })`
- * without knowing about pino.
- */
-function adaptLogger(name: string): Logger {
-  const pino = getLogger(name);
-  return {
-    debug: (msg, meta) => pino.debug(meta ?? {}, msg),
-    info: (msg, meta) => pino.info(meta ?? {}, msg),
-    warn: (msg, meta) => pino.warn(meta ?? {}, msg),
-    error: (msg, meta) => pino.error(meta ?? {}, msg),
-  };
-}
-
-function buildLoggerFacet(skillId: string): LoggerFacet {
-  return {
-    get: (name) => adaptLogger(`${skillId}:${name}`),
-  };
-}
-
-function buildConfigFacet(): ConfigFacet {
-  return {
-    isFeatureFlagEnabled: (key) =>
-      isAssistantFeatureFlagEnabled(key, getConfig()),
-    getSection: <T>(path: string): T | undefined =>
-      getNestedValue(
-        getConfig() as unknown as Record<string, unknown>,
-        path,
-      ) as T | undefined,
-  };
-}
-
-function buildIdentityFacet(): IdentityFacet {
-  return {
-    // Contract uses `undefined`; delegate returns `null`. Normalize here.
-    getAssistantName: () => getAssistantName() ?? undefined,
-  };
-}
-
-function buildPlatformFacet(): PlatformFacet {
-  return {
-    workspaceDir: () => getWorkspaceDir(),
-    vellumRoot: () => vellumRoot(),
-    runtimeMode: () => getDaemonRuntimeMode(),
-  };
-}
-
-function buildLlmProvidersFacet(): LlmProvidersFacet {
-  return {
-    getConfigured: async (callSite) =>
-      (await getConfiguredProvider(callSite as LLMCallSite)) as Provider | null,
-    userMessage: (text) => userMessage(text) as unknown as UserMessage,
-    extractToolUse: (response) =>
-      (extractToolUse(response as Parameters<typeof extractToolUse>[0]) ??
-        null) as ToolUse | null,
-    createTimeout,
-  };
-}
-
-function buildSttProvidersFacet(): SttProvidersFacet {
-  return {
-    listProviderIds: () => [...sttListProviderIds()],
-    // Contract asks whether a provider id is usable; we check against the
-    // daemon-streaming boundary which is the only boundary skills currently
-    // care about. Passes the id through to the daemon helper.
-    supportsBoundary: (id) =>
-      sttSupportsBoundary(
-        id as Parameters<typeof sttSupportsBoundary>[0],
-        "daemon-streaming",
-      ),
-    resolveStreamingTranscriber: async (spec) =>
-      (await sttResolveStreamingTranscriber(
-        spec as Parameters<typeof sttResolveStreamingTranscriber>[0],
-      )) as StreamingTranscriber | null,
-  };
-}
-
-function buildTtsProvidersFacet(): TtsProvidersFacet {
-  return {
-    get: (id) => getTtsProvider(id as never) as unknown as TtsProvider,
-    // `resolveTtsConfig` needs the current config; the contract takes no
-    // args, so we fetch `getConfig()` at call time and pass it through.
-    resolveConfig: () => resolveTtsConfig(getConfig()) as unknown as TtsConfig,
-  };
-}
-
-function buildSecureKeysFacet(): SecureKeysFacet {
-  return {
-    // Daemon returns `undefined`; contract returns `null`. Normalize.
-    getProviderKey: async (id) => (await getProviderKeyAsync(id)) ?? null,
-  };
-}
-
-function buildProvidersFacet(): ProvidersFacet {
-  return {
-    llm: buildLlmProvidersFacet(),
-    stt: buildSttProvidersFacet(),
-    tts: buildTtsProvidersFacet(),
-    secureKeys: buildSecureKeysFacet(),
-  };
-}
-
-function buildMemoryFacet(): MemoryFacet {
-  return {
-    addMessage: addMessage,
-    wakeAgentForOpportunity: async (req) => {
-      // Contract returns `void`; daemon returns a `WakeResult` that
-      // in-process callers don't need through the host surface.
-      await wakeAgentForOpportunity(req as never);
-    },
-  };
-}
-
-function buildEventsFacet(): EventsFacet {
-  return {
-    // Contract types events/messages as opaque supersets of the daemon's
-    // narrower discriminated unions; cast at the boundary so
-    // `assistantEventHub` continues to accept its existing type.
-    publish: (event: AssistantEvent) =>
-      assistantEventHub.publish(event as never),
-    subscribe: (filter: Filter, cb: AssistantEventCallback): Subscription =>
-      assistantEventHub.subscribe({
-        type: "process",
-        filter,
-        callback: cb,
-      }),
-    // `buildAssistantEvent` takes `(message, conversationId?)`.
-    buildEvent: (message: ServerMessage, conversationId?: string) =>
-      buildAssistantEvent(message as never, conversationId) as AssistantEvent,
-  };
-}
-
-function buildRegistriesFacet(skillId: string): RegistriesFacet {
-  return {
-    // Contract's `Tool` is structurally independent of the daemon's
-    // overlay (`assistant/src/tools/types.ts`); the assistant-side
-    // registry accepts the daemon flavor. Skills construct tools via
-    // helpers that already produce the daemon shape, so a cast at this
-    // boundary is safe. The contract's `registerTools(provider)` stays
-    // single-arg — skill code never needs to know its own id — and this
-    // adapter pairs the provider with the owner derived from the
-    // surrounding {@link buildRegistriesFacet} closure.
-    registerTools: (provider) =>
-      registerExternalTools({ kind: "skill", id: skillId }, provider as never),
-    registerSkillRoute: (route: SkillRoute): SkillRouteHandle =>
-      registerSkillRoute(route) as unknown as SkillRouteHandle,
-    // Namespace hook names by skillId so two skills using the same label
-    // (e.g. "cleanup") cannot silently overwrite each other's entries in
-    // the shared shutdown-hook map.
-    registerShutdownHook: (name, hook) =>
-      registerShutdownHook(`${skillId}:${name}`, hook),
-  };
-}
-
-function buildSpeakersFacet(): SpeakersFacet {
-  return {
-    createTracker: () => new SpeakerIdentityTracker(),
-  };
-}
-
-/**
- * Build a `SkillHost` for the in-process first-party skill identified by
- * `skillId`. The id prefixes logger names (so cross-cutting diagnostics
- * carry the owning skill) and namespaces shutdown-hook registrations (so
- * two skills using the same hook label cannot silently overwrite each
- * other in the shared shutdown-hook map).
- */
-export function createDaemonSkillHost(skillId: string): SkillHost {
-  return {
-    logger: buildLoggerFacet(skillId),
-    config: buildConfigFacet(),
-    identity: buildIdentityFacet(),
-    platform: buildPlatformFacet(),
-    providers: buildProvidersFacet(),
-    memory: buildMemoryFacet(),
-    events: buildEventsFacet(),
-    registries: buildRegistriesFacet(skillId),
-    speakers: buildSpeakersFacet(),
-  };
-}

package/src/daemon/message-types/meet.ts

@@ -1,143 +0,0 @@
-/**
- * Meet — server → client push messages for live meeting state.
- *
- * Emitted by the assistant daemon as the Meet-bot progresses through its
- * lifecycle (joining → joined → left) and as in-meeting state changes
- * (participants, active speaker, transcript chunks).
- *
- * Keep payloads small and client-actionable: these events power the
- * macOS "In meeting" status panel and the conversation bridge's live
- * transcript feed. A client that missed an event can always refetch
- * authoritative state from the daemon's HTTP routes.
- */
-
-/** A single participant in a meeting. Shape mirrors the wire-level type. */
-export interface MeetParticipant {
-  /** Stable participant identifier (provider-specific). */
-  id: string;
-  /** Display name of the participant. */
-  name: string;
-  /** Whether the participant is the meeting host. */
-  isHost?: boolean;
-  /** Whether the participant is the bot itself. */
-  isSelf?: boolean;
-}
-
-/** The bot has started attempting to join a meeting. */
-export interface MeetJoining {
-  type: "meet.joining";
-  meetingId: string;
-  /** The Meet URL the bot was asked to join. */
-  url: string;
-}
-
-/** The bot has successfully joined and is live in the meeting. */
-export interface MeetJoined {
-  type: "meet.joined";
-  meetingId: string;
-}
-
-/** Participants joined and/or left the meeting since the last snapshot. */
-export interface MeetParticipantChanged {
-  type: "meet.participant_changed";
-  meetingId: string;
-  /** Participants who joined since the last snapshot. */
-  joined: MeetParticipant[];
-  /** Participants who left since the last snapshot. */
-  left: MeetParticipant[];
-}
-
-/** The active speaker in the meeting changed. */
-export interface MeetSpeakerChanged {
-  type: "meet.speaker_changed";
-  meetingId: string;
-  /** Stable speaker identifier for the new active speaker. */
-  speakerId: string;
-  /** Display name of the new active speaker. */
-  speakerName: string;
-}
-
-/**
- * A finalized chunk of transcribed speech. Interim chunks are filtered
- * out before publication so clients only render stable text.
- */
-export interface MeetTranscriptChunk {
-  type: "meet.transcript_chunk";
-  meetingId: string;
-  /** The transcribed text. */
-  text: string;
-  /** Human-readable speaker label, if the ASR provided one. */
-  speakerLabel?: string;
-  /** Stable speaker identifier across the meeting, if available. */
-  speakerId?: string;
-  /** ASR confidence in [0, 1], if available. */
-  confidence?: number;
-}
-
-/** The bot has left the meeting. */
-export interface MeetLeft {
-  type: "meet.left";
-  meetingId: string;
-  /** Free-form reason passed to `leave()` (e.g. "user-requested", "timeout"). */
-  reason: string;
-}
-
-/**
- * The assistant successfully posted a chat message into the meeting via
- * the bot's `/send_chat` endpoint. Emitted once per successful send so
- * SSE-subscribed clients can render the outbound chat without waiting for
- * the bot to echo it back through the transcript/chat stream.
- */
-export interface MeetChatSent {
-  type: "meet.chat_sent";
-  meetingId: string;
-  /** The text that was posted into the meeting's chat. */
-  text: string;
-}
-
-/** The bot hit a non-recoverable error (container crash, join failure, etc.). */
-export interface MeetError {
-  type: "meet.error";
-  meetingId: string;
-  /** Human-readable error detail. */
-  detail: string;
-}
-
-/**
- * The assistant has begun speaking into the meeting via the TTS bridge. Fired
- * once per {@link MeetSessionManager.speak} invocation immediately before the
- * synthesis stream starts flowing to the bot's `/play_audio` endpoint. Useful
- * for clients that want to render a "speaking …" indicator.
- */
-export interface MeetSpeakingStarted {
-  type: "meet.speaking_started";
-  meetingId: string;
-  /** Opaque stream identifier — matches `meet.speaking_ended.streamId`. */
-  streamId: string;
-}
-
-/**
- * The assistant has finished (or cancelled) a TTS playback stream. Fired
- * after the bot-side playback request settles — whether normally, via an
- * explicit cancel, or due to an upstream error.
- */
-export interface MeetSpeakingEnded {
-  type: "meet.speaking_ended";
-  meetingId: string;
-  /** Opaque stream identifier — matches `meet.speaking_started.streamId`. */
-  streamId: string;
-  /** Why the stream ended: natural completion, caller-initiated cancel, or an upstream error. */
-  reason: "completed" | "cancelled" | "error";
-}
-
-export type _MeetServerMessages =
-  | MeetJoining
-  | MeetJoined
-  | MeetParticipantChanged
-  | MeetSpeakerChanged
-  | MeetTranscriptChunk
-  | MeetLeft
-  | MeetChatSent
-  | MeetError
-  | MeetSpeakingStarted
-  | MeetSpeakingEnded;

package/src/daemon/shutdown-registry.ts

@@ -1,40 +0,0 @@
-/**
- * Registry for skill shutdown hooks.
- *
- * Skills register async shutdown callbacks at initialization time. The daemon
- * calls {@link runShutdownHooks} during graceful shutdown so skill-owned
- * resources (containers, sockets, etc.) are torn down before the process exits.
- */
-
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("shutdown-registry");
-
-type ShutdownHook = (reason: string) => Promise<void>;
-
-const hooks = new Map<string, ShutdownHook>();
-
-/**
- * Register a named shutdown hook. Called by skills at initialization time.
- * If a hook with the same name already exists it is silently replaced (supports
- * hot-reload).
- */
-export function registerShutdownHook(name: string, hook: ShutdownHook): void {
-  hooks.set(name, hook);
-  log.info({ name }, "Shutdown hook registered");
-}
-
-/**
- * Run all registered shutdown hooks. Each hook receives a human-readable
- * `reason` string (e.g. "daemon-shutdown"). Failures are logged but do not
- * prevent other hooks from running.
- */
-export async function runShutdownHooks(reason: string): Promise<void> {
-  for (const [name, hook] of hooks) {
-    try {
-      await hook(reason);
-    } catch (err) {
-      log.warn({ err, name }, `Shutdown hook "${name}" failed (non-fatal)`);
-    }
-  }
-}

package/src/ipc/__tests__/skill-server-bidirectional.test.ts

@@ -1,253 +0,0 @@
-/**
- * Bidirectional RPC smoke test for the skill IPC channel.
- *
- * Spins up `SkillIpcServer` on a temp socket and connects a real
- * `SkillHostClient`. Verifies the daemon→skill direction end-to-end:
- *   - Happy path: server `sendRequest` resolves with the handler's return.
- *   - Handler-throw path: server `sendRequest` rejects with the thrown
- *     error message.
- *   - Missing-handler path: server `sendRequest` rejects with a "method
- *     not found" error.
- *   - Connection-close path: server `sendRequest` rejects with a clear
- *     "connection closed" error when the peer disconnects mid-flight.
- *
- * Sits in the assistant package (not the contracts package) because it
- * exercises both `SkillIpcServer` and `SkillHostClient` — the contracts
- * package's own tests deliberately stand up a stub server to avoid a
- * dependency on `assistant/`.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { connect, type Socket } from "node:net";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { SkillHostClient } from "@vellumai/skill-host-contracts";
-
-import {
-  SKILL_IPC_DAEMON_ID_PREFIX,
-  type SkillIpcConnection,
-  SkillIpcServer,
-} from "../skill-server.js";
-
-// ---------------------------------------------------------------------------
-// Harness
-// ---------------------------------------------------------------------------
-
-let tempDir: string | null = null;
-let socketPath: string | null = null;
-let server: SkillIpcServer | null = null;
-let client: SkillHostClient | null = null;
-let savedSkillIpcSocketDir: string | undefined;
-
-beforeEach(() => {
-  savedSkillIpcSocketDir = process.env.ASSISTANT_SKILL_IPC_SOCKET_DIR;
-  tempDir = mkdtempSync(join(tmpdir(), "skill-ipc-bidir-"));
-  process.env.ASSISTANT_SKILL_IPC_SOCKET_DIR = tempDir;
-  socketPath = join(tempDir, "assistant-skill.sock");
-});
-
-afterEach(async () => {
-  client?.close();
-  client = null;
-  server?.stop();
-  server = null;
-  if (savedSkillIpcSocketDir === undefined) {
-    delete process.env.ASSISTANT_SKILL_IPC_SOCKET_DIR;
-  } else {
-    process.env.ASSISTANT_SKILL_IPC_SOCKET_DIR = savedSkillIpcSocketDir;
-  }
-  if (tempDir) {
-    rmSync(tempDir, { recursive: true, force: true });
-    tempDir = null;
-    socketPath = null;
-  }
-});
-
-/**
- * Stand up the server, connect a client, and return the
- * server-side `SkillIpcConnection` handle once the connection is
- * established. The handle is the target the daemon's `sendRequest`
- * needs.
- */
-async function startPair(): Promise<{
-  server: SkillIpcServer;
-  client: SkillHostClient;
-  connection: SkillIpcConnection;
-}> {
-  if (!socketPath) throw new Error("socketPath not initialized");
-  const srv = new SkillIpcServer();
-  await srv.start();
-  const c = new SkillHostClient({
-    socketPath,
-    skillId: "bidir-test",
-  });
-  // Stub the routes the contracts client prefetches at connect-time.
-  srv.registerMethod("host.identity.getAssistantName", () => null);
-  srv.registerMethod("host.platform.workspaceDir", () => "/tmp/workspace");
-  srv.registerMethod("host.platform.vellumRoot", () => "/tmp/vellum");
-  srv.registerMethod("host.platform.runtimeMode", () => "bare-metal");
-
-  await c.connect();
-  // The server does not expose its per-socket connection map publicly
-  // (it is a WeakMap keyed by the `Socket` object). Reach in via the
-  // private fields — acceptable for a same-package smoke test that
-  // needs the `SkillIpcConnection` handle to call `sendRequest`.
-  const internals = srv as unknown as {
-    clients: Set<object>;
-    connections: WeakMap<object, SkillIpcConnection>;
-  };
-  const connections: SkillIpcConnection[] = [];
-  for (const sock of internals.clients) {
-    const conn = internals.connections.get(sock);
-    if (conn) connections.push(conn);
-  }
-  if (connections.length !== 1) {
-    throw new Error(
-      `expected exactly one server-side connection, got ${connections.length}`,
-    );
-  }
-  const connection = connections[0]!;
-  server = srv;
-  client = c;
-  return { server: srv, client: c, connection };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("SkillIpcServer.sendRequest", () => {
-  test("happy path — registered handler returns a value", async () => {
-    const pair = await startPair();
-    pair.client.registerHandler("echo", (params) => ({ got: params }));
-
-    const result = await pair.server.sendRequest(pair.connection, "echo", {
-      hi: "there",
-    });
-    expect(result).toEqual({ got: { hi: "there" } });
-  });
-
-  test("happy path — async handler is awaited", async () => {
-    const pair = await startPair();
-    pair.client.registerHandler("delayed", async (params) => {
-      await new Promise((r) => setTimeout(r, 10));
-      return { delayed: true, params };
-    });
-
-    const result = await pair.server.sendRequest(pair.connection, "delayed", {
-      tag: 7,
-    });
-    expect(result).toEqual({ delayed: true, params: { tag: 7 } });
-  });
-
-  test("handler error — rejected with the thrown message", async () => {
-    const pair = await startPair();
-    pair.client.registerHandler("boom", () => {
-      throw new Error("kaboom");
-    });
-
-    await expect(
-      pair.server.sendRequest(pair.connection, "boom"),
-    ).rejects.toThrow(/kaboom/);
-  });
-
-  test("missing handler — rejected with method-not-found", async () => {
-    const pair = await startPair();
-    // No handler registered for "missing".
-
-    await expect(
-      pair.server.sendRequest(pair.connection, "missing"),
-    ).rejects.toThrow(/method not found/);
-  });
-
-  test("connection close — rejects in-flight requests with a clear error", async () => {
-    const pair = await startPair();
-    // Handler that never returns so the request stays in-flight until the
-    // peer disconnects.
-    pair.client.registerHandler("hang", () => new Promise(() => {}));
-
-    const inFlight = pair.server.sendRequest(pair.connection, "hang");
-    // Force the client side to drop the socket. The server's "close"
-    // handler will then dispose the connection state and reject every
-    // pending daemon-initiated request.
-    pair.client.close();
-
-    await expect(inFlight).rejects.toThrow(/connection closed/);
-  });
-
-  test("daemon-initiated id prefix is `d:`", () => {
-    // Public-constant assertion: the `d:` prefix is part of the wire
-    // contract — peers (e.g. the contracts client) read it directly to
-    // route inbound frames. A future rename here without updating the
-    // peers would silently break bidirectional dispatch, so the
-    // constant is asserted.
-    expect(SKILL_IPC_DAEMON_ID_PREFIX).toBe("d:");
-  });
-
-  test("server rejects inbound skill-initiated requests whose ids start with `d:`", async () => {
-    if (!socketPath) throw new Error("socketPath not initialized");
-    const srv = new SkillIpcServer();
-    await srv.start();
-    server = srv;
-    srv.registerMethod("test.echo", (params) => ({ ok: true, params }));
-
-    // Send a request with a reserved-prefix id over a raw socket so we
-    // bypass the contracts client (which never mints `d:` ids).
-    const response = await new Promise<{
-      id: string;
-      error?: string;
-      result?: unknown;
-    }>((resolve, reject) => {
-      const sock: Socket = connect(socketPath!);
-      let buffer = "";
-      let settled = false;
-      const finish = (
-        v: { id: string; error?: string; result?: unknown } | Error,
-      ): void => {
-        if (settled) return;
-        settled = true;
-        sock.destroy();
-        if (v instanceof Error) reject(v);
-        else resolve(v);
-      };
-      sock.on("connect", () => {
-        sock.write(JSON.stringify({ id: "d:99", method: "test.echo" }) + "\n");
-      });
-      sock.on("data", (chunk) => {
-        buffer += chunk.toString();
-        const idx = buffer.indexOf("\n");
-        if (idx === -1) return;
-        const line = buffer.slice(0, idx).trim();
-        try {
-          finish(JSON.parse(line));
-        } catch (err) {
-          finish(err as Error);
-        }
-      });
-      sock.on("error", (err) => finish(err));
-    });
-
-    expect(response.id).toBe("d:99");
-    expect(response.result).toBeUndefined();
-    expect(response.error).toMatch(/Reserved id prefix/);
-  });
-
-  test("existing skill→daemon RPCs still succeed alongside daemon→skill ones", async () => {
-    const pair = await startPair();
-    pair.server.registerMethod("test.add", (params) => {
-      const p = params as { a: number; b: number };
-      return p.a + p.b;
-    });
-    pair.client.registerHandler("client-echo", (params) => params);
-
-    // Round-trip both directions concurrently.
-    const [skillResult, daemonResult] = await Promise.all([
-      pair.client.rawCall<number>("test.add", { a: 2, b: 3 }),
-      pair.server.sendRequest(pair.connection, "client-echo", { value: "ok" }),
-    ]);
-    expect(skillResult).toBe(5);
-    expect(daemonResult).toEqual({ value: "ok" });
-  });
-});