@vellumai/assistant 0.7.0 → 0.7.1

package/src/home/relationship-state-writer.ts

@@ -32,7 +32,6 @@ import { listConnections } from "../oauth/oauth-store.js";
 import { resolveGuardianPersonaPath } from "../prompts/persona-resolver.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -318,7 +317,7 @@ export async function writeRelationshipState(): Promise<void> {
 function publishRelationshipStateUpdated(updatedAt: string): void {
   assistantEventHub
     .publish(
-      buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+      buildAssistantEvent({
         type: "relationship_state_updated",
         updatedAt,
       }),
@@ -423,6 +422,20 @@ function safeRead(path: string): string {
   }
 }
 
+/**
+ * Map personality-group tone IDs (from onboarding) to human-readable
+ * voice descriptions displayed as relationship-state facts.
+ * Unrecognized values (e.g. legacy `"balanced"` or free-text tones from
+ * older clients) fall through via the `?? tone` fallback in
+ * `extractFacts`.
+ */
+const TONE_VOICE_MAP: Record<string, string> = {
+  grounded: "Calm and precise",
+  warm: "Warm and easy",
+  energetic: "Fast and direct",
+  poetic: "Quiet and observant",
+};
+
 /**
  * Walk the workspace prompt files and emit a flat list of inferred
  * facts. This is deliberately a simple bullet/heading parser — the TDD
@@ -478,7 +491,7 @@ function extractFacts(input: {
       facts.push({
         id: nextId("onboarding"),
         category: "voice",
-        text: tone,
+        text: TONE_VOICE_MAP[tone] ?? tone,
         confidence: "strong",
         source: "onboarding",
       });

package/src/ipc/__tests__/browser-ipc.test.ts

@@ -23,16 +23,13 @@ let mockOperationCalls: Array<{
   input: Record<string, unknown>;
   conversationId: string;
   trustClass?: string;
-  hostBrowserProxy?: unknown;
   transportInterface?: string;
 }> = [];
 
 /** When set, findConversation returns a fake conversation object. */
 let mockConversation: {
   trustContext?: { trustClass: string };
-  hostBrowserProxy?: unknown;
   transportInterface?: string;
-  hostBrowserSenderOverride?: unknown;
 } | null = null;
 
 let mockFindConversationCalls: string[] = [];
@@ -44,7 +41,6 @@ mock.module("../../browser/operations.js", () => ({
     context: {
       conversationId: string;
       trustClass?: string;
-      hostBrowserProxy?: unknown;
       transportInterface?: string;
     },
   ) => {
@@ -53,7 +49,6 @@ mock.module("../../browser/operations.js", () => ({
       input,
       conversationId: context.conversationId,
       trustClass: context.trustClass,
-      hostBrowserProxy: context.hostBrowserProxy,
       transportInterface: context.transportInterface,
     });
     return mockOperationResult;
@@ -68,9 +63,8 @@ mock.module("../../daemon/conversation-store.js", () => ({
 }));
 
 // Import after mocking — now from the shared routes location
-const { ROUTES, browserCliConversationKey } = await import(
-  "../../runtime/routes/browser-routes.js"
-);
+const { ROUTES, browserCliConversationKey } =
+  await import("../../runtime/routes/browser-routes.js");
 
 const browserExecuteHandler = ROUTES.find(
   (r) => r.operationId === "browser_execute",
@@ -190,12 +184,9 @@ describe("browser_execute route", () => {
   });
 
   test("uses live conversation context fields when found", async () => {
-    const fakeProxy = { isAvailable: () => true };
     mockConversation = {
       trustContext: { trustClass: "trusted" },
-      hostBrowserProxy: fakeProxy,
       transportInterface: "chrome-extension",
-      hostBrowserSenderOverride: { some: "sender" },
     };
 
     await callHandler({
@@ -209,7 +200,6 @@ describe("browser_execute route", () => {
     expect(mockOperationCalls[0]).toMatchObject({
       conversationId: "conv-live-456",
       trustClass: "trusted",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "chrome-extension",
     });
   });

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

@@ -84,7 +84,6 @@ async function startPair(): Promise<{
     skillId: "bidir-test",
   });
   // Stub the routes the contracts client prefetches at connect-time.
-  srv.registerMethod("host.identity.getInternalAssistantId", () => "self");
   srv.registerMethod("host.identity.getAssistantName", () => null);
   srv.registerMethod("host.platform.workspaceDir", () => "/tmp/workspace");
   srv.registerMethod("host.platform.vellumRoot", () => "/tmp/vellum");

package/src/ipc/assistant-server.ts

@@ -44,7 +44,7 @@ import {
   writeStreamChunk,
   writeStreamEnd,
 } from "./ipc-framing.js";
-import { type DbProxyParams,handleDbProxy } from "./routes/db-proxy.js";
+import { type DbProxyParams, handleDbProxy } from "./routes/db-proxy.js";
 import { routeDefinitionsToIpcMethods } from "./routes/route-adapter.js";
 import { ensureSocketPathFree } from "./socket-cleanup.js";
 import { resolveIpcSocketPath } from "./socket-path.js";
@@ -73,9 +73,6 @@ export type IpcResponse = {
   headers?: Record<string, string>;
 };
 
-
-
-
 /**
  * Wrapper returned by route handlers that produce a streaming response.
  * The IPC server detects this and pipes the ReadableStream as chunked
@@ -95,9 +92,7 @@ export interface IpcBinaryResponse {
   headers: Record<string, string>;
 }
 
-export function isIpcStreamingResponse(
-  value: unknown,
-): value is IpcStreamingResponse {
+function isIpcStreamingResponse(value: unknown): value is IpcStreamingResponse {
   return (
     value != null &&
     typeof value === "object" &&
@@ -108,9 +103,7 @@ export function isIpcStreamingResponse(
   );
 }
 
-export function isIpcBinaryResponse(
-  value: unknown,
-): value is IpcBinaryResponse {
+function isIpcBinaryResponse(value: unknown): value is IpcBinaryResponse {
   return (
     value != null &&
     typeof value === "object" &&

package/src/ipc/routes/__tests__/memory-v2-backfill.test.ts

@@ -8,7 +8,7 @@
  * Coverage:
  *   1. method name is the public verb expected by the CLI.
  *   2. unknown params are rejected (defensive — the schema is `.strict()`).
- *   3. each of the four ops dispatches to the correct `MemoryJobType`.
+ *   3. each of the three ops dispatches to the correct `MemoryJobType`.
  *   4. `migrate` with `force: true` propagates the flag in the payload.
  *   5. `migrate` without `force` (and ops that ignore `force`) sends an
  *      empty payload — the `false` default never reaches the queue.
@@ -17,6 +17,8 @@
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import * as realJobsStore from "../../../memory/jobs-store.js";
+
 // ---------------------------------------------------------------------------
 // Module-level mock — capture every enqueue call so each test can assert the
 // route forwarded the correct (type, payload) tuple. The route file is
@@ -29,15 +31,35 @@ const enqueueCalls: Array<{
 }> = [];
 let nextJobId = 0;
 
+// Spread the real module's exports so transitive importers (e.g.
+// memory/auto-analysis-enqueue.ts pulled in via the CLI program → memory
+// indexer chain) get every named export they bind to at module-load time;
+// only `enqueueMemoryJob` is overridden so the route under test forwards
+// to the test stub. jobs-store.ts has no side-effecting top-level
+// statements, so loading it for the spread is safe.
 mock.module("../../../memory/jobs-store.js", () => ({
+  ...realJobsStore,
   enqueueMemoryJob: (type: string, payload: Record<string, unknown>) => {
     enqueueCalls.push({ type, payload });
     nextJobId += 1;
     return `test-job-${nextJobId}`;
   },
+  upsertAutoAnalysisJob: () => {},
+  upsertDebouncedJob: () => `test-debounced-${++nextJobId}`,
+  hasActiveJobOfType: () => false,
+  enqueuePruneOldLlmRequestLogsJob: () => `test-prune-${++nextJobId}`,
+  enqueuePruneOldConversationsJob: () => `test-prune-conv-${++nextJobId}`,
+  claimMemoryJobs: () => [],
+  completeMemoryJob: () => {},
+  deferMemoryJob: () => "deferred",
+  failMemoryJob: () => {},
+  resetRunningJobsToPending: () => 0,
+  failStalledJobs: () => 0,
+  getMemoryJobCounts: () => ({}),
 }));
 
-const { ROUTES: memoryV2Routes } = await import("../../../runtime/routes/memory-v2-routes.js");
+const { ROUTES: memoryV2Routes } =
+  await import("../../../runtime/routes/memory-v2-routes.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -45,7 +67,9 @@ const { ROUTES: memoryV2Routes } = await import("../../../runtime/routes/memory-
 
 type BackfillResult = { jobId: string };
 
-const backfillRoute = memoryV2Routes.find(r => r.operationId === "memory_v2_backfill")!;
+const backfillRoute = memoryV2Routes.find(
+  (r) => r.operationId === "memory_v2_backfill",
+)!;
 
 async function runRoute(
   params: Record<string, unknown>,
@@ -109,27 +133,22 @@ describe("memory_v2_backfill route", () => {
     expect(enqueueCalls).toEqual([{ type: "memory_v2_migrate", payload: {} }]);
   });
 
-  test("rebuild-edges enqueues memory_v2_rebuild_edges with empty payload", async () => {
-    await runRoute({ op: "rebuild-edges" });
+  test("rebuild-edges op is rejected (no longer supported)", async () => {
+    await expect(runRoute({ op: "rebuild-edges" })).rejects.toThrow();
+    expect(enqueueCalls).toEqual([]);
+  });
 
-    expect(enqueueCalls).toEqual([
-      { type: "memory_v2_rebuild_edges", payload: {} },
-    ]);
+  test("reembed enqueues memory_v2_reembed with empty payload", async () => {
+    await runRoute({ op: "reembed" });
+
+    expect(enqueueCalls).toEqual([{ type: "memory_v2_reembed", payload: {} }]);
   });
 
-  test("rebuild-edges ignores force flag", async () => {
+  test("reembed ignores force flag", async () => {
     // `force` only has meaning for `migrate`. For other ops we still accept
     // the field (so a single CLI flag works across all ops without
     // branching) but never forward it to the queue.
-    await runRoute({ op: "rebuild-edges", force: true });
-
-    expect(enqueueCalls).toEqual([
-      { type: "memory_v2_rebuild_edges", payload: {} },
-    ]);
-  });
-
-  test("reembed enqueues memory_v2_reembed with empty payload", async () => {
-    await runRoute({ op: "reembed" });
+    await runRoute({ op: "reembed", force: true });
 
     expect(enqueueCalls).toEqual([{ type: "memory_v2_reembed", payload: {} }]);
   });
@@ -143,8 +162,8 @@ describe("memory_v2_backfill route", () => {
   });
 
   test("returns the jobId emitted by enqueueMemoryJob", async () => {
-    const first = await runRoute({ op: "rebuild-edges" });
-    const second = await runRoute({ op: "reembed" });
+    const first = await runRoute({ op: "reembed" });
+    const second = await runRoute({ op: "activation-recompute" });
 
     expect(first.jobId).toBe("test-job-1");
     expect(second.jobId).toBe("test-job-2");

package/src/ipc/routes/route-adapter.ts

@@ -6,7 +6,7 @@
 import type { RouteDefinition } from "../../runtime/routes/types.js";
 
 function isIpcEligible(r: RouteDefinition): boolean {
-  return !r.requireGuardian && !r.isPublic && !r.requirePolicyEnforcement;
+  return !r.requireGuardian && !r.isPublic;
 }
 
 export function routeDefinitionsToIpcMethods(

package/src/ipc/routes/trust-rules.test.ts

@@ -3,9 +3,6 @@
  *
  * Covers:
  * - trust_rules_list: no params, tool filter, include_all, origin filter
- * - trust_rules_create: correct POST URL and JSON body
- * - trust_rules_update: PATCH URL, partial body, throws when id missing
- * - trust_rules_remove: DELETE URL, throws when id missing
  * - error path: non-OK gateway response surfaces body .error message
  */
 
@@ -111,98 +108,6 @@ describe("trustRuleRoutes", () => {
     });
   });
 
-  describe("trust_rules_create", () => {
-    test("POSTs to /v1/trust-rules with correct JSON body", async () => {
-      mockFetchResponse = {
-        ok: true,
-        status: 201,
-        json: async () => ({ rule: { id: "rule-1" } }),
-      };
-
-      const route = findRoute("trust_rules_create");
-      await route.handler({ body: {
-        tool: "bash",
-        pattern: "rm -rf *",
-        risk: "high",
-        description: "Dangerous remove",
-      } });
-
-      expect(capturedFetchCalls).toHaveLength(1);
-      const call = capturedFetchCalls[0];
-      expect(call.url).toBe("http://localhost:7822/v1/trust-rules");
-      expect(call.init?.method).toBe("POST");
-      expect((call.init?.headers as Record<string, string>)["Content-Type"]).toBe(
-        "application/json",
-      );
-      const body = JSON.parse(call.init?.body as string) as Record<
-        string,
-        unknown
-      >;
-      expect(body).toEqual({
-        tool: "bash",
-        pattern: "rm -rf *",
-        risk: "high",
-        description: "Dangerous remove",
-      });
-    });
-  });
-
-  describe("trust_rules_update", () => {
-    test("PATCHes /v1/trust-rules/abc-123", async () => {
-      const route = findRoute("trust_rules_update");
-      await route.handler({ body: { id: "abc-123", risk: "low", description: "Safe" } });
-
-      expect(capturedFetchCalls).toHaveLength(1);
-      const call = capturedFetchCalls[0];
-      expect(call.url).toBe("http://localhost:7822/v1/trust-rules/abc-123");
-      expect(call.init?.method).toBe("PATCH");
-    });
-
-    test("body contains only fields present in params (partial update)", async () => {
-      const route = findRoute("trust_rules_update");
-      await route.handler({ body: { id: "abc-123", risk: "low" } });
-
-      const body = JSON.parse(
-        capturedFetchCalls[0].init?.body as string,
-      ) as Record<string, unknown>;
-      expect(body.risk).toBe("low");
-      expect("description" in body).toBe(false);
-    });
-
-    test("throws when id is missing", async () => {
-      const route = findRoute("trust_rules_update");
-      await expect(
-        route.handler({ body: { risk: "low" } }),
-      ).rejects.toThrow("id is required");
-    });
-
-    test("throws when id is empty string", async () => {
-      const route = findRoute("trust_rules_update");
-      await expect(
-        route.handler({ body: { id: "", risk: "low" } }),
-      ).rejects.toThrow("id is required");
-    });
-  });
-
-  describe("trust_rules_remove", () => {
-    test("DELETEs /v1/trust-rules/abc-123", async () => {
-      const route = findRoute("trust_rules_remove");
-      await route.handler({ body: { id: "abc-123" } });
-
-      expect(capturedFetchCalls).toHaveLength(1);
-      const call = capturedFetchCalls[0];
-      expect(call.url).toBe("http://localhost:7822/v1/trust-rules/abc-123");
-      expect(call.init?.method).toBe("DELETE");
-    });
-
-    test("throws when id is missing", async () => {
-      const route = findRoute("trust_rules_remove");
-      await expect(
-        route.handler({ body: {} }),
-      ).rejects.toThrow("id is required");
-    });
-  });
-
   describe("error path", () => {
     test("non-OK response surfaces body .error message", async () => {
       mockFetchResponse = {

package/src/ipc/skill-ipc-types.ts

@@ -11,3 +11,44 @@ export type SkillIpcRoute = {
   method: string;
   handler: SkillMethodHandler;
 };
+
+// ---------------------------------------------------------------------------
+// Streaming types
+// ---------------------------------------------------------------------------
+
+export interface SkillIpcStream {
+  /** The original request id that opened this stream (used as the stream id). */
+  readonly id: string;
+  /**
+   * Send a delivery frame to the client. No-op after the stream has been
+   * closed (client disconnect, explicit close, or server shutdown).
+   */
+  send(payload: unknown): void;
+  /**
+   * Terminate the stream from the server side. Sends a final error frame to
+   * the client (if `errorMessage` is provided and the socket is still
+   * writable), invokes the handler-returned dispose, and unregisters the
+   * stream from the per-socket subscription map. Idempotent — subsequent
+   * calls are no-ops.
+   */
+  close(errorMessage?: string): void;
+  /** True until the stream has been disposed. */
+  readonly active: boolean;
+}
+
+/**
+ * Handler signature for long-lived streaming methods (e.g.
+ * `host.events.subscribe`). Runs synchronously with the opening request and
+ * returns a dispose callback that the server invokes on client disconnect,
+ * explicit close, or server shutdown.
+ */
+export type SkillIpcStreamingHandler = (
+  stream: SkillIpcStream,
+  params?: Record<string, unknown>,
+) => () => void;
+
+/** Long-lived streaming route — method name + handler function. */
+export type SkillIpcStreamingRoute = {
+  method: string;
+  handler: SkillIpcStreamingHandler;
+};

package/src/ipc/skill-routes/__tests__/events-ipc.test.ts

@@ -7,7 +7,7 @@
  * - `host.events.publish` — publishes an event and verifies it reaches the
  *   daemon's `assistantEventHub` exactly as an in-process publish would.
  * - `host.events.buildEvent` — verifies deterministic envelope construction
- *   under `DAEMON_INTERNAL_ASSISTANT_ID`.
+ *   with the expected shape.
  * - `host.events.subscribe` — long-lived stream: confirms open ack, filtered
  *   delivery (match vs. mismatch), explicit close, and cleanup on client
  *   disconnect (including that the hub releases its subscription slot).
@@ -21,7 +21,6 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import type { AssistantEvent } from "../../../runtime/assistant-event.js";
 import { assistantEventHub } from "../../../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../../runtime/assistant-scope.js";
 import { SkillIpcServer } from "../../skill-server.js";
 
 // ---------------------------------------------------------------------------
@@ -144,18 +143,17 @@ async function waitForSubscriberCount(
 describe("host.events.publish", () => {
   test("publish round-trip reaches assistantEventHub subscribers", async () => {
     const received: AssistantEvent[] = [];
-    const subscription = assistantEventHub.subscribe(
-      { assistantId: "test-asst" },
-      (evt) => {
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (evt) => {
         received.push(evt);
       },
-    );
+    });
 
     try {
       const client = await openClient();
       const event = {
         id: "evt-1",
-        assistantId: "test-asst",
         conversationId: "conv-1",
         emittedAt: new Date().toISOString(),
         message: { type: "test_message", foo: "bar" },
@@ -171,7 +169,6 @@ describe("host.events.publish", () => {
 
       expect(received).toHaveLength(1);
       expect(received[0]?.id).toBe("evt-1");
-      expect(received[0]?.assistantId).toBe("test-asst");
       expect((received[0]?.message as unknown as { foo: string }).foo).toBe(
         "bar",
       );
@@ -198,7 +195,7 @@ describe("host.events.publish", () => {
 });
 
 describe("host.events.buildEvent", () => {
-  test("returns an envelope attributed to DAEMON_INTERNAL_ASSISTANT_ID", async () => {
+  test("returns a well-formed event envelope", async () => {
     const client = await openClient();
     const conversationId = "conv-xyz";
     const message = { type: "assistant_text_delta", text: "hi" };
@@ -211,7 +208,6 @@ describe("host.events.buildEvent", () => {
     const frame = await client.nextFrame();
     expect("result" in frame).toBe(true);
     const built = (frame as { result: AssistantEvent }).result;
-    expect(built.assistantId).toBe(DAEMON_INTERNAL_ASSISTANT_ID);
     expect(built.conversationId).toBe(conversationId);
     expect(typeof built.id).toBe("string");
     expect(typeof built.emittedAt).toBe("string");
@@ -222,7 +218,7 @@ describe("host.events.buildEvent", () => {
 });
 
 describe("host.events.subscribe", () => {
-  test("opens ack, delivers matching events, filters non-matching", async () => {
+  test("opens ack, delivers matching events, filters non-matching conversations", async () => {
     const baseSubscribers = assistantEventHub.subscriberCount();
     const client = await openClient();
     client.send({
@@ -230,7 +226,6 @@ describe("host.events.subscribe", () => {
       method: "host.events.subscribe",
       params: {
         filter: {
-          assistantId: "asst-a",
           conversationId: "conv-a",
         },
       },
@@ -265,16 +260,7 @@ describe("host.events.subscribe", () => {
       message: { type: "t2" },
     } as never);
 
-    // Non-matching event on a different assistant.
-    await assistantEventHub.publish({
-      id: "e3",
-      assistantId: "asst-b",
-      conversationId: "conv-a",
-      emittedAt: new Date().toISOString(),
-      message: { type: "t3" },
-    } as never);
-
-    // Confirm no delivery frame arrives for the non-matching events by
+    // Confirm no delivery frame arrives for the non-matching event by
     // publishing another matching event and asserting ordering.
     await assistantEventHub.publish({
       id: "e4",
@@ -300,7 +286,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-2",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-close" } },
+      params: { filter: {} },
     });
     await client.nextFrame(); // ack
     expect(assistantEventHub.subscriberCount()).toBe(baseSubscribers + 1);
@@ -324,7 +310,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-3",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-leak" } },
+      params: { filter: {} },
     });
     await client.nextFrame(); // ack
     expect(assistantEventHub.subscriberCount()).toBe(baseSubscribers + 1);
@@ -352,7 +338,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-4",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-stop" } },
+      params: { filter: {} },
     });
     await client.nextFrame(); // ack
     expect(assistantEventHub.subscriberCount()).toBe(baseSubscribers + 1);
@@ -371,7 +357,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-dup",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-dup" } },
+      params: { filter: {} },
     });
     const ack = await client.nextFrame();
     expect("result" in ack && ack.result).toEqual({ subscribed: true });
@@ -379,7 +365,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-dup",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-dup" } },
+      params: { filter: {} },
     });
     const err = await client.nextFrame();
     expect("error" in err && err.error).toContain("sub-dup");

package/src/ipc/skill-routes/__tests__/identity.test.ts

@@ -1,8 +1,7 @@
 /**
  * Unit tests for the `host.identity.*` skill IPC routes. Mocks
  * `getAssistantName()` so we can assert both the resolved-name and
- * missing-name paths, and pins the internal assistant ID to the
- * canonical "self" constant.
+ * missing-name paths.
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -17,11 +16,8 @@ mock.module("../../../daemon/identity-helpers.js", () => ({
   getAssistantName: () => mockName,
 }));
 
-const {
-  hostIdentityGetAssistantNameRoute,
-  hostIdentityGetInternalAssistantIdRoute,
-  identityRoutes,
-} = await import("../identity.js");
+const { hostIdentityGetAssistantNameRoute, identityRoutes } =
+  await import("../identity.js");
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -59,23 +55,8 @@ describe("host.identity.getAssistantName IPC route", () => {
   });
 });
 
-describe("host.identity.getInternalAssistantId IPC route", () => {
-  test("method is host.identity.getInternalAssistantId", () => {
-    expect(hostIdentityGetInternalAssistantIdRoute.method).toBe(
-      "host.identity.getInternalAssistantId",
-    );
-  });
-
-  test("returns the daemon internal assistant id constant", async () => {
-    const result = await hostIdentityGetInternalAssistantIdRoute.handler();
-
-    expect(result).toBe("self");
-  });
-});
-
 describe("identityRoutes", () => {
-  test("exports both identity routes", () => {
+  test("exports the identity route", () => {
     expect(identityRoutes).toContain(hostIdentityGetAssistantNameRoute);
-    expect(identityRoutes).toContain(hostIdentityGetInternalAssistantIdRoute);
   });
 });