@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

package/src/runtime/routes/acp-routes.ts

@@ -4,23 +4,31 @@
  * Exposes spawn, steer, cancel, close, sessions, and permission operations
  * over HTTP and IPC.
  */
-import { desc, eq, inArray } from "drizzle-orm";
+import { randomUUID } from "node:crypto";
+
+import { and, desc, eq, inArray, notInArray } from "drizzle-orm";
 import { z } from "zod";
 
+import { resolveAgentWithAutoInstall } from "../../acp/auto-install.js";
 import { getAcpSessionManager } from "../../acp/index.js";
 import { prepareAgentEnv } from "../../acp/prepare-agent-env.js";
-import { resolveAcpAgent } from "../../acp/resolve-agent.js";
+import { formatResolveFailure } from "../../acp/resolve-agent.js";
+import { AcpResumeError } from "../../acp/session-manager.js";
 import type { AcpSessionState } from "../../acp/types.js";
+import { getConfig } from "../../config/loader.js";
 import { getDb } from "../../memory/db-connection.js";
 import { rawChanges } from "../../memory/raw-query.js";
 import { acpSessionHistory } from "../../memory/schema.js";
+import type { UserDecision } from "../../permissions/types.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import * as pendingInteractions from "../pending-interactions.js";
 import {
   BadRequestError,
   ConflictError,
   FailedDependencyError,
+  ForbiddenError,
   NotFoundError,
 } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -51,7 +59,109 @@ type SessionEntry = z.infer<typeof sessionEntrySchema>;
 // Handlers
 // ---------------------------------------------------------------------------
 
-async function spawnSession({ body }: RouteHandlerArgs) {
+/**
+ * Surface a high-risk confirmation for an ACP route that starts a host agent
+ * subprocess (`POST /v1/acp/spawn`, and the resume branch of
+ * `POST /v1/acp/:id/steer`) and resolve to the guardian's decision.
+ *
+ * Unlike the `acp_spawn` / `acp_steer` skill tools (which are dispatched
+ * through `ToolExecutor`/`PermissionChecker` and so inherit the descriptors'
+ * `risk: "high"` approval prompt), these HTTP/IPC routes reach the ACP
+ * session manager directly. A spawned ACP agent is a host subprocess with
+ * advertised filesystem + terminal access whose in-session permission
+ * requests are auto-allowed, so starting one is exactly the high-risk action
+ * the descriptors gate. Without this prompt a caller holding only
+ * `chat.write` could start one with no human in the loop — directly via
+ * spawn (arbitrary `cwd`), or by resuming a terminal session via steer (its
+ * persisted `cwd`, enumerable through `GET /v1/acp/sessions`) (ATL-822).
+ *
+ * The confirmation is registered with `directResolve` so `POST /v1/confirm`
+ * resolves it without a live `Conversation` object. That route requires the
+ * bound guardian (`approval.write` + `requireGuardian`) — a strictly higher
+ * bar than the `chat.write` these routes demand — so the `chat.write` caller
+ * cannot self-approve. Timeout and client disconnect both deny, matching the
+ * tool path's "no interactive client → do not run" posture.
+ */
+function awaitRouteApproval(args: {
+  toolName: string;
+  input: Record<string, unknown>;
+  conversationId: string;
+  signal?: AbortSignal;
+}): Promise<UserDecision> {
+  const { toolName, input, conversationId, signal } = args;
+  const requestId = randomUUID();
+  // Mirror the interactive prompt timeout; fall back to the schema default
+  // (300s) if the timeouts block is somehow absent so the gate never wedges.
+  const timeoutMs = (getConfig().timeouts?.permissionTimeoutSec ?? 300) * 1000;
+
+  return new Promise<UserDecision>((resolve) => {
+    let settled = false;
+    const settle = (
+      decision: UserDecision,
+      state: "approved" | "rejected" | "cancelled",
+    ) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      // Idempotent: the `/v1/confirm` directResolve path already removed the
+      // entry before invoking us, so this is a no-op there and only fires
+      // `interaction_resolved` for the timeout/abort paths.
+      pendingInteractions.resolve(requestId, state);
+      resolve(decision);
+    };
+
+    const timer = setTimeout(() => {
+      log.warn(
+        { requestId, toolName, conversationId },
+        "ACP route approval timed out — denying",
+      );
+      settle("deny", "cancelled");
+    }, timeoutMs);
+
+    const onAbort = () => settle("deny", "cancelled");
+    if (signal?.aborted) {
+      clearTimeout(timer);
+      resolve("deny");
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+
+    pendingInteractions.register(requestId, {
+      conversationId,
+      kind: "confirmation",
+      confirmationDetails: {
+        toolName,
+        input,
+        riskLevel: "high",
+        executionTarget: "host",
+        allowlistOptions: [],
+        scopeOptions: [],
+        persistentDecisionsAllowed: false,
+      },
+      directResolve: (decision) =>
+        settle(decision, decision === "allow" ? "approved" : "rejected"),
+    });
+
+    broadcastMessage(
+      {
+        type: "confirmation_request",
+        requestId,
+        toolName,
+        input,
+        riskLevel: "high",
+        executionTarget: "host",
+        allowlistOptions: [],
+        scopeOptions: [],
+        conversationId,
+        persistentDecisionsAllowed: false,
+      },
+      conversationId,
+    );
+  });
+}
+
+async function spawnSession({ body, abortSignal }: RouteHandlerArgs) {
   const agent = body?.agent as string | undefined;
   const task = body?.task as string | undefined;
   const conversationId = body?.conversationId as string | undefined;
@@ -61,26 +171,35 @@ async function spawnSession({ body }: RouteHandlerArgs) {
     throw new BadRequestError("agent, task, and conversationId are required");
   }
 
-  const resolved = resolveAcpAgent(agent);
+  // High-risk approval gate. Block BEFORE any side effects — resolution can
+  // trigger a `bun` global install (auto-install.ts) and `manager.spawn`
+  // launches the host subprocess — so an unapproved request mutates nothing.
+  const decision = await awaitRouteApproval({
+    toolName: "acp_spawn",
+    input: { agent, task, cwd },
+    conversationId,
+    signal: abortSignal,
+  });
+  if (decision !== "allow") {
+    throw new ForbiddenError(
+      "Spawning an ACP coding agent requires guardian approval, which was " +
+        "not granted.",
+    );
+  }
+
+  // Resolve the agent, silently auto-installing a missing allowlisted
+  // adapter binary (see acp/auto-install.ts). Shared with the skill-tool
+  // path in tools/acp/spawn.ts; only the transport mapping differs.
+  const { resolved, failureMessage } = await resolveAgentWithAutoInstall(agent);
+  if (failureMessage) {
+    throw new FailedDependencyError(failureMessage);
+  }
   if (!resolved.ok) {
-    switch (resolved.reason) {
-      case "acp_disabled":
-        throw new BadRequestError(resolved.hint);
-      case "unknown_agent":
-        throw new BadRequestError(
-          `Unknown agent "${agent}". Available: ${resolved.available.join(", ")}.`,
-        );
-      case "binary_not_found":
-        throw new FailedDependencyError(
-          `${resolved.command} is not on PATH. ${resolved.hint}`,
-        );
-      default: {
-        const _exhaustive: never = resolved;
-        throw new Error(
-          `Unexpected acp resolver reason: ${(_exhaustive as { reason: string }).reason}`,
-        );
-      }
+    const message = formatResolveFailure(agent, resolved);
+    if (resolved.reason === "binary_not_found") {
+      throw new FailedDependencyError(message);
     }
+    throw new BadRequestError(message);
   }
 
   // Inject required env vars and preflight via the shared helper. See
@@ -116,13 +235,143 @@ async function steerSession({ pathParams, body }: RouteHandlerArgs) {
     throw new BadRequestError("instruction is required");
   }
 
+  // Sessions no longer in memory (completed, or lost to a daemon restart)
+  // are transparently resumed from persisted history with the instruction
+  // fired in the same call, mirroring the acp_steer skill tool.
+  // broadcastMessage plays the sender role spawnSession gives it, so
+  // connected clients render the session.
   const manager = getAcpSessionManager();
+
+  // Resume re-spawns the host agent subprocess, so it crosses the same
+  // high-risk boundary as spawn and needs guardian approval (ATL-822). A
+  // steer of a session still active in memory only redirects an
+  // already-running, already-approved process, so it is left unprompted —
+  // matching "gate before spawning". A resume only happens when the id is
+  // absent from memory AND a resumable history row (non-null cwd) exists.
+  if (!manager.getActiveAndPendingIds().includes(id)) {
+    const resumable = getDb()
+      .select({
+        cwd: acpSessionHistory.cwd,
+        agentId: acpSessionHistory.agentId,
+        parentConversationId: acpSessionHistory.parentConversationId,
+      })
+      .from(acpSessionHistory)
+      .where(eq(acpSessionHistory.id, id))
+      .get();
+    if (resumable?.cwd != null) {
+      // Guardian approval is an out-of-band human action that can take far
+      // longer than a client's ack timeout (the macOS client uses 10s; the
+      // approval window is permissionTimeoutSec, default 300s). Blocking the
+      // HTTP response here would surface as a client transport failure even
+      // on an eventual approval. Acknowledge immediately and run approval +
+      // resume in the background, streaming via SSE like any other ACP
+      // activity. The request abortSignal is deliberately NOT threaded into
+      // the wait — the request is already complete.
+      void approveThenResume({
+        id,
+        instruction,
+        agentId: resumable.agentId,
+        cwd: resumable.cwd,
+        conversationId: resumable.parentConversationId,
+      });
+      return { acpSessionId: id, steered: false, approvalPending: true };
+    }
+  }
+
   try {
-    await manager.steer(id, instruction);
-  } catch {
+    const { resumed } = await manager.steerOrResume(
+      id,
+      instruction,
+      broadcastMessage,
+    );
+    return resumed
+      ? { acpSessionId: id, steered: true, resumed: true }
+      : { acpSessionId: id, steered: true };
+  } catch (err) {
+    // Resume errors carry the actionable hint (legacy row without cwd,
+    // agent capability missing, resolver failures, ...).
+    if (err instanceof AcpResumeError) {
+      throw new FailedDependencyError(err.message);
+    }
+    // Unknown ids (no in-memory session, no history row) and plain steer
+    // failures both map to 404, as before.
     throw new NotFoundError("ACP session not found");
   }
-  return { acpSessionId: id, steered: true };
+}
+
+/**
+ * Background worker for an approval-gated ACP resume initiated over the steer
+ * route. Awaits the guardian decision (see `awaitRouteApproval`), then resumes
+ * via the session manager so the agent's output streams back over SSE. A
+ * denial, timeout, or resume failure is surfaced as an `acp_session_error` on
+ * the parent conversation so the client isn't left with an optimistic steer
+ * row and no follow-up. Never throws — it owns the request lifecycle after the
+ * route has already acked.
+ */
+async function approveThenResume(args: {
+  id: string;
+  instruction: string;
+  agentId: string;
+  cwd: string;
+  conversationId: string;
+}): Promise<void> {
+  const decision = await awaitRouteApproval({
+    toolName: "acp_steer",
+    input: {
+      acp_session_id: args.id,
+      instruction: args.instruction,
+      agent: args.agentId,
+      cwd: args.cwd,
+    },
+    conversationId: args.conversationId,
+  });
+
+  if (decision !== "allow") {
+    log.info(
+      { acpSessionId: args.id, conversationId: args.conversationId },
+      "ACP resume approval not granted — skipping resume",
+    );
+    broadcastMessage(
+      {
+        type: "acp_session_error",
+        // Key the error by the daemon session id (the value the steer route
+        // accepts and ACP SSE consumers index by — see registerSession, where
+        // state.id is the broadcast acpSessionId), NOT the persisted protocol
+        // id. A denied resume never emits acp_session_spawned to map the
+        // protocol id, so a protocol-keyed error would be dropped.
+        acpSessionId: args.id,
+        error: "Resume was not approved.",
+      },
+      args.conversationId,
+    );
+    return;
+  }
+
+  try {
+    await getAcpSessionManager().steerOrResume(
+      args.id,
+      args.instruction,
+      broadcastMessage,
+    );
+  } catch (err) {
+    const message =
+      err instanceof AcpResumeError || err instanceof Error
+        ? err.message
+        : String(err);
+    log.warn(
+      { acpSessionId: args.id, conversationId: args.conversationId, err },
+      "Approved ACP resume failed",
+    );
+    broadcastMessage(
+      {
+        type: "acp_session_error",
+        // Daemon session id (route + SSE key), not the protocol id — see above.
+        acpSessionId: args.id,
+        error: message,
+      },
+      args.conversationId,
+    );
+  }
 }
 
 async function cancelSession({ pathParams }: RouteHandlerArgs) {
@@ -161,9 +410,25 @@ function bulkDeleteSessions({ queryParams }: RouteHandlerArgs) {
       "status query param is required and must be 'completed'",
     );
   }
+  // Exclude sessions currently active in memory AND ids with a resume in
+  // flight (reserved but not yet registered): a resumed session reuses its
+  // original id, and its history row keeps the old terminal status until
+  // the next terminal upsert - a status-only delete would remove the row
+  // out from under the live (or resuming) session, and the later terminal
+  // upsert would resurrect it. Mirrors the 409 guard on the single-id
+  // delete route.
+  const activeIds = getAcpSessionManager().getActiveAndPendingIds();
+  const terminalFilter = inArray(
+    acpSessionHistory.status,
+    TERMINAL_SESSION_STATUSES,
+  );
   getDb()
     .delete(acpSessionHistory)
-    .where(inArray(acpSessionHistory.status, TERMINAL_SESSION_STATUSES))
+    .where(
+      activeIds.length > 0
+        ? and(terminalFilter, notInArray(acpSessionHistory.id, activeIds))
+        : terminalFilter,
+    )
     .run();
   const deleted = rawChanges();
   log.info({ deleted }, "Bulk-cleared terminal ACP session history");
@@ -172,9 +437,10 @@ function bulkDeleteSessions({ queryParams }: RouteHandlerArgs) {
 
 function deleteSession({ pathParams }: RouteHandlerArgs) {
   const id = pathParams?.id as string;
+  const manager = getAcpSessionManager();
 
   try {
-    const state = getAcpSessionManager().getStatus(id);
+    const state = manager.getStatus(id);
     if (
       !Array.isArray(state) &&
       (state.status === "running" || state.status === "initializing")
@@ -185,7 +451,16 @@ function deleteSession({ pathParams }: RouteHandlerArgs) {
     }
   } catch (err) {
     if (err instanceof ConflictError) throw err;
-    // Not in memory — fall through to the (idempotent) DB delete.
+    // Not registered in memory, but a resume may be in flight (id reserved
+    // while awaiting env preparation). Its history row must survive until
+    // the resume lands - the later terminal upsert would resurrect a
+    // deleted row.
+    if (manager.getActiveAndPendingIds().includes(id)) {
+      throw new ConflictError(
+        `ACP session "${id}" has a resume in flight. Wait for it to finish before deleting.`,
+      );
+    }
+    // Otherwise fall through to the (idempotent) DB delete.
   }
 
   getDb().delete(acpSessionHistory).where(eq(acpSessionHistory.id, id)).run();
@@ -233,7 +508,14 @@ export const ROUTES: RouteDefinition[] = [
     },
     handler: steerSession,
     summary: "Steer ACP session",
-    description: "Send a steering instruction to an active ACP session.",
+    description:
+      "Send a steering instruction to an ACP session. Sessions no longer " +
+      "in memory (completed, or lost to a daemon restart) are " +
+      "transparently resumed from persisted history first, when the agent " +
+      "supports ACP session loading. Resuming a terminal session re-spawns " +
+      "the host agent, so it requires guardian approval: the route acks " +
+      "immediately with approvalPending=true and performs the resume in the " +
+      "background once approved, streaming results over SSE.",
     tags: ["acp"],
     requestBody: z.object({
       instruction: z.string(),
@@ -241,6 +523,19 @@ export const ROUTES: RouteDefinition[] = [
     responseBody: z.object({
       acpSessionId: z.string(),
       steered: z.boolean(),
+      resumed: z
+        .boolean()
+        .optional()
+        .describe(
+          "True when the session was resumed from persisted history before steering.",
+        ),
+      approvalPending: z
+        .boolean()
+        .optional()
+        .describe(
+          "True when the steer triggered a guardian-approval-gated resume " +
+            "that will run asynchronously; watch SSE for the outcome.",
+        ),
     }),
   },
   {
@@ -324,7 +619,9 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Bulk-clear terminal ACP sessions",
     description:
       "Remove every terminal-state row (completed/failed/cancelled) from " +
-      "the persisted acp_session_history table.",
+      "the persisted acp_session_history table. Rows whose session is " +
+      "currently active in memory (e.g. resumed) or has a resume in " +
+      "flight are excluded.",
     tags: ["acp"],
     queryParams: [
       {
@@ -350,7 +647,8 @@ export const ROUTES: RouteDefinition[] = [
     summary: "Delete ACP session from history",
     description:
       "Remove a persisted ACP session row. Rejects with 409 when the " +
-      "session is still active in memory; idempotent for unknown ids.",
+      "session is still active in memory or has a resume in flight; " +
+      "idempotent for unknown ids.",
     tags: ["acp"],
     responseBody: z.object({
       deleted: z.boolean(),

package/src/runtime/routes/app-management-routes.ts

@@ -89,6 +89,7 @@ function listAppsFiltered(apps?: AppDefinition[]): Array<{
   description?: string;
   icon?: string;
   createdAt: number;
+  updatedAt: number;
   version: string;
   contentId: string;
 }> {
@@ -101,6 +102,7 @@ function listAppsFiltered(apps?: AppDefinition[]): Array<{
       description: a.description,
       icon: a.icon,
       createdAt: a.createdAt,
+      updatedAt: a.updatedAt,
       version,
       contentId,
     };
@@ -751,6 +753,7 @@ export const ROUTES: RouteDefinition[] = [
           description: z.string().optional(),
           icon: z.string().optional(),
           createdAt: z.number(),
+          updatedAt: z.number(),
           version: z.string(),
           contentId: z.string(),
         }),

package/src/runtime/routes/approval-routes.ts

@@ -9,7 +9,7 @@
  */
 import { z } from "zod";
 
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import { getConversationByKey } from "../../memory/conversation-key-store.js";
 import type { UserDecision } from "../../permissions/types.js";
 import { getLogger } from "../../util/logger.js";

package/src/runtime/routes/browser-routes.ts

@@ -16,7 +16,7 @@ import {
   BROWSER_OPERATIONS,
   type BrowserOperation,
 } from "../../browser/types.js";
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import type { ContentBlock } from "../../providers/types.js";
 import { LOCAL_PRINCIPALS } from "../auth/route-policy.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";

package/src/runtime/routes/browser-tabs-routes.ts

@@ -7,7 +7,7 @@
 
 import { z } from "zod";
 
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import { getCdpClient } from "../../tools/browser/cdp-client/factory.js";
 import {
   clearPinnedTab,
@@ -73,11 +73,7 @@ async function handleBrowserTabs({ body = {} }: RouteHandlerArgs) {
           ? result.clientId
           : undefined;
       if (result?.tabId !== undefined) {
-        setPinnedTab(
-          resolvedConversationId,
-          String(result.tabId),
-          clientId,
-        );
+        setPinnedTab(resolvedConversationId, String(result.tabId), clientId);
       }
       return { ok: true, tab: result };
     } finally {
@@ -88,10 +84,10 @@ async function handleBrowserTabs({ body = {} }: RouteHandlerArgs) {
   if (command === "new") {
     const cdp = getCdpClient(context, cdpOptions);
     try {
-      const result = await cdp.send<{ tabId?: number | string; clientId?: string }>(
-        "Vellum.createTab",
-        {},
-      );
+      const result = await cdp.send<{
+        tabId?: number | string;
+        clientId?: string;
+      }>("Vellum.createTab", {});
       // Normalise to string for internal use (setCdpSessionId / setPinnedTab)
       // and keep the numeric form for the API response.
       const newTabIdStr: string | undefined =

package/src/runtime/routes/channel-verification-routes.ts

@@ -23,6 +23,7 @@ import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { revokePendingSessions } from "../channel-verification-service.js";
 import {
   cancelOutbound,
+  deliverVerificationEmail,
   deliverVerificationSlack,
   normalizeTelegramDestination,
   resendOutbound,
@@ -139,11 +140,15 @@ export async function handleCreateVerificationSession({
       verificationRateLimiter.recordFailure(rateLimitKey);
     }
 
-    // Dispatch Slack DM delivery from the daemon process (not sandboxed).
+    // Dispatch delivery from the daemon process (not sandboxed).
     if (result._pendingSlackDm) {
       const { userId, text, assistantId: aid } = result._pendingSlackDm;
       deliverVerificationSlack(userId, text, aid);
     }
+    if (result._pendingEmail) {
+      const { to, text, subject, assistantId: aid } = result._pendingEmail;
+      deliverVerificationEmail(to, text, subject, aid);
+    }
 
     if (!result.success) {
       if (result.error === "rate_limited") {
@@ -157,8 +162,8 @@ export async function handleCreateVerificationSession({
       );
     }
 
-    // Strip internal field from the response
-    const { _pendingSlackDm: _, ...publicResult } = result;
+    // Strip internal fields from the response
+    const { _pendingSlackDm: _, _pendingEmail: __, ...publicResult } = result;
     return publicResult;
   }
 
@@ -204,11 +209,15 @@ export async function handleResendVerificationSession({
 
   const result = resendOutbound({ channel, originConversationId });
 
-  // Dispatch Slack DM delivery from the daemon process (not sandboxed).
+  // Dispatch delivery from the daemon process (not sandboxed).
   if (result._pendingSlackDm) {
     const { userId, text, assistantId: aid } = result._pendingSlackDm;
     deliverVerificationSlack(userId, text, aid);
   }
+  if (result._pendingEmail) {
+    const { to, text, subject, assistantId: aid } = result._pendingEmail;
+    deliverVerificationEmail(to, text, subject, aid);
+  }
 
   if (!result.success) {
     if (result.error === "rate_limited") {
@@ -221,7 +230,7 @@ export async function handleResendVerificationSession({
     );
   }
 
-  const { _pendingSlackDm: _, ...publicResult } = result;
+  const { _pendingSlackDm: _, _pendingEmail: __, ...publicResult } = result;
   return publicResult;
 }
 

package/src/runtime/routes/conversation-cli-routes.ts

@@ -9,7 +9,7 @@
 import { v4 as uuid } from "uuid";
 import { z } from "zod";
 
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import { clearAllConversations as clearAllActive } from "../../daemon/handlers/conversations.js";
 import { formatJson, formatMarkdown } from "../../export/formatter.js";
 import { ipcCall as ipcCallGateway } from "../../ipc/gateway-client.js";

package/src/runtime/routes/conversation-list-routes.ts

@@ -9,7 +9,7 @@
 
 import { z } from "zod";
 
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import {
   type Confidence,
   getAttentionStateByConversationIds,

package/src/runtime/routes/conversation-query-routes.ts

@@ -72,7 +72,7 @@ import { type LogRow } from "../../memory/llm-request-log-store.js";
 import { getMemoryRecallLogByMessageIds } from "../../memory/memory-recall-log-store.js";
 import { getMemoryV2ActivationLogByMessageIds } from "../../memory/memory-v2-activation-log-store.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../memory/v2/constants.js";
-import { getMemoryV3SelectionForInspector } from "../../memory/v3/selection-log-store.js";
+import { getMemoryV3SelectionForInspector } from "../../plugins/defaults/memory-v3-shadow/selection-log-store.js";
 import {
   createConnection,
   listConnections,