@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/__tests__/surface-completion-in-flight-snapshot.test.ts

@@ -104,6 +104,7 @@ function makeContext(): Conversation {
     conversationId: CONVERSATION_ID,
     trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
     sendToClient: () => {},
+    emit: () => {},
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

package/src/__tests__/tool-execution-pipeline.benchmark.test.ts

@@ -93,7 +93,7 @@ mock.module("../skills/version-hash.js", () => ({
 // In CI there's no gateway, so we return a sensible default.
 mock.module("../ipc/gateway-client.js", () => ({
   ipcClassifyRisk: async (): Promise<
-    import("../permissions/ipc-risk-types.js").ClassificationResult
+    import("@vellumai/gateway-client").ClassifyRiskIpcResponse
   > => ({
     risk: "low",
     reason: "mock",

package/src/__tests__/tool-executor-lifecycle-events.test.ts

@@ -6,9 +6,11 @@ import type { UsageAttributionSnapshot } from "../usage/attribution.js";
 let checkerDecision: "allow" | "prompt" | "deny" = "allow";
 let checkerReason = "allowed";
 let checkerRisk = "low";
+let classifyThrow: Error | null = null;
 let promptDecision: "allow" | "deny" = "allow";
 let fakeToolResult: ToolExecutionResult = { content: "ok", isError: false };
 let toolThrow: Error | null = null;
+let grantConsumeOk = false;
 
 // ── audit-terminal captures ───────────────────────────────
 // The executor and its permission/approval collaborators no longer emit
@@ -86,13 +88,38 @@ mock.module("../platform/consent-cache.js", () => ({
 
 mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => false,
-  classifyRisk: async () => ({ level: checkerRisk }),
+  // Mirrors the real classifier's two failure modes: it throws on an aborted
+  // signal before doing anything, and it throws when the gateway is
+  // unreachable.
+  classifyRisk: async (
+    _name: string,
+    _input: Record<string, unknown>,
+    _workingDir?: string,
+    _preParsed?: unknown,
+    _manifestOverride?: unknown,
+    signal?: AbortSignal,
+  ) => {
+    signal?.throwIfAborted();
+    if (classifyThrow) {
+      throw classifyThrow;
+    }
+    return { level: checkerRisk };
+  },
   check: async () => ({ decision: checkerDecision, reason: checkerReason }),
-  generateAllowlistOptions: () => [
-    { label: "exact", description: "exact", pattern: "exact" },
-  ],
   generateScopeOptions: () => [{ label: "/tmp", scope: "/tmp" }],
-  getCachedAssessment: () => undefined,
+}));
+
+// The scoped-grant consume the gate performs for a sensitive tool invoked by
+// an unknown actor. `mintGrantFromDecision` is stubbed only so the module's
+// other importer links; nothing here mints.
+mock.module("../approvals/approval-primitive.js", () => ({
+  consumeGrantForInvocation: async () =>
+    grantConsumeOk
+      ? { ok: true, grant: { id: "grant-1" } }
+      : { ok: false, reason: "no_match" },
+  mintGrantFromDecision: async () => {
+    throw new Error("mintGrantFromDecision should not be called");
+  },
 }));
 
 mock.module("../persistence/conversation-crud.js", () => ({
@@ -255,9 +282,11 @@ describe("ToolExecutor audit terminals", () => {
     checkerDecision = "allow";
     checkerReason = "allowed";
     checkerRisk = "low";
+    classifyThrow = null;
     promptDecision = "allow";
     fakeToolResult = { content: "ok", isError: false };
     toolThrow = null;
+    grantConsumeOk = false;
     executedCaptures.length = 0;
     errorCaptures.length = 0;
     deniedCaptures.length = 0;
@@ -786,4 +815,102 @@ describe("ToolExecutor audit terminals", () => {
     expect(executedCaptures).toHaveLength(1);
     expect(executedCaptures[0].toolName).toBe("file_edit");
   });
+
+  // ── audit riskLevel on rows the permission check never produces ─────────
+  // The classifier runs before the pre-execution gates, so a gate denial, a
+  // gate error, and a grant-consumed execution all record the call's real
+  // risk rather than a placeholder (LUM-3159).
+
+  test("a gate-denied call records the classified risk, not a placeholder", async () => {
+    checkerRisk = "high";
+    const executor = new ToolExecutor(makePrompter());
+
+    // Verification control-plane paths are guardian-only; an unknown actor is
+    // denied by the gate before any permission check.
+    const result = await executor.execute(
+      "bash",
+      { command: "curl http://host/v1/channel-verification-sessions" },
+      makeContext({ trustClass: "unknown" }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(deniedCaptures).toHaveLength(1);
+    expect(deniedCaptures[0].riskLevel).toBe("high");
+    expect(deniedCaptures[0].wasPrompted).toBe(false);
+  });
+
+  test("a gate-errored call records the classified risk", async () => {
+    checkerRisk = "medium";
+    const executor = new ToolExecutor(makePrompter());
+
+    await executor.execute("unknown_tool", { test: true }, makeContext());
+
+    expect(errorCaptures).toHaveLength(1);
+    expect(errorCaptures[0].errorMessage).toContain("Unknown tool");
+    expect(errorCaptures[0].riskLevel).toBe("medium");
+  });
+
+  test("a grant-consumed execution records the classified risk", async () => {
+    checkerRisk = "high";
+    grantConsumeOk = true;
+    const executor = new ToolExecutor(makePrompter());
+
+    // A sensitive tool from an unknown actor routes through the scoped-grant
+    // consume; a consumed grant skips the permission check entirely, so this
+    // is the one executed row whose risk the permission check never supplies.
+    const result = await executor.execute(
+      "file_write",
+      { path: "/tmp/project/out.txt", content: "x" },
+      makeContext({ trustClass: "unknown" }),
+    );
+
+    expect(result).toMatchObject({
+      isError: false,
+      approvalReason: "grant_scoped_consumed",
+    });
+    expect(executedCaptures).toHaveLength(1);
+    expect(executedCaptures[0].decision).toBe("allow");
+    expect(executedCaptures[0].riskLevel).toBe("high");
+  });
+
+  test("a call whose classification never completes records 'unclassified', not 'low'", async () => {
+    classifyThrow = new Error("gateway unreachable");
+    const executor = new ToolExecutor(makePrompter());
+
+    // Gate error path: the row says the risk was never assessed.
+    await executor.execute("unknown_tool", { test: true }, makeContext());
+    expect(errorCaptures).toHaveLength(1);
+    expect(errorCaptures[0].riskLevel).toBe("unclassified");
+
+    // Past the gates, the permission check still requires a classification
+    // and fails closed; that error row is likewise honest about the risk.
+    errorCaptures.length = 0;
+    const result = await executor.execute(
+      "file_read",
+      { path: "README.md" },
+      makeContext(),
+    );
+    expect(result.isError).toBe(true);
+    expect(executedCaptures).toHaveLength(0);
+    expect(errorCaptures).toHaveLength(1);
+    expect(errorCaptures[0].errorMessage).toContain("gateway unreachable");
+    expect(errorCaptures[0].riskLevel).toBe("unclassified");
+  });
+
+  test("a call aborted before it starts records 'unclassified' on its cancelled row", async () => {
+    checkerRisk = "high";
+    const executor = new ToolExecutor(makePrompter());
+    const controller = new AbortController();
+    controller.abort();
+
+    const result = await executor.execute(
+      "bash",
+      { command: "rm -rf /tmp" },
+      makeContext({ signal: controller.signal }),
+    );
+
+    expect(result).toEqual({ content: "Cancelled", isError: true });
+    expect(errorCaptures).toHaveLength(1);
+    expect(errorCaptures[0].riskLevel).toBe("unclassified");
+  });
 });

package/src/__tests__/tool-executor.test.ts

@@ -43,8 +43,11 @@ let checkFnOverride:
 /** Override for generateScopeOptions — when set, returns this value instead of the default. */
 let scopeOptionsOverride: ScopeOption[] | undefined;
 
-/** Override for getCachedAssessment — when set, returns this value. */
-let cachedAssessmentOverride:
+/**
+ * Override for the classification `classifyRisk` returns; when unset the
+ * classifier answers low with no reason and no options.
+ */
+let classificationOverride:
   | {
       riskLevel: string;
       reason: string;
@@ -61,7 +64,14 @@ let cachedAssessmentOverride:
 
 mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => false,
-  classifyRisk: async () => ({ level: "low" }),
+  classifyRisk: async () => ({
+    level: classificationOverride?.riskLevel ?? "low",
+    reason: classificationOverride?.reason,
+    scopeOptions: classificationOverride?.scopeOptions ?? [],
+    allowlistOptions: classificationOverride?.allowlistOptions,
+    directoryScopeOptions: classificationOverride?.directoryScopeOptions,
+    matchType: classificationOverride?.matchType ?? "unknown",
+  }),
   check: async (
     toolName: string,
     input: Record<string, unknown>,
@@ -77,12 +87,8 @@ mock.module("../permissions/checker.js", () => ({
     }
     return { decision: "allow", reason: "allowed" };
   },
-  generateAllowlistOptions: () => [
-    { label: "exact", description: "exact", pattern: "exact" },
-  ],
   generateScopeOptions: () =>
     scopeOptionsOverride ?? [{ label: "/tmp", scope: "/tmp" }],
-  getCachedAssessment: () => cachedAssessmentOverride,
 }));
 
 // Mock every export so downstream test files that dynamically import modules
@@ -167,7 +173,7 @@ describe("ToolExecutor allowedToolNames gating", () => {
     getAllToolsOverride = undefined;
     checkResultOverride = undefined;
     checkFnOverride = undefined;
-    cachedAssessmentOverride = undefined;
+    classificationOverride = undefined;
   });
 
   test("executes normally when allowedToolNames is not set", async () => {
@@ -385,7 +391,7 @@ describe("ToolExecutor policy context plumbing", () => {
     getToolOverride = undefined;
     checkResultOverride = undefined;
     checkFnOverride = undefined;
-    cachedAssessmentOverride = undefined;
+    classificationOverride = undefined;
   });
 
   test("passes PolicyContext with executionTarget for skill-origin tools", async () => {
@@ -604,7 +610,7 @@ describe("ToolExecutor forcePromptSideEffects enforcement", () => {
     getToolOverride = undefined;
     checkResultOverride = undefined;
     checkFnOverride = undefined;
-    cachedAssessmentOverride = undefined;
+    classificationOverride = undefined;
     promptCalled = false;
   });
 
@@ -931,11 +937,30 @@ describe("integration regressions — prompt payload (PR 11)", () => {
     getToolOverride = undefined;
   });
 
-  test("shell command prompt payload includes allowlist and scope options", async () => {
+  test("shell command prompt payload carries the classifier's ladder and the scope options", async () => {
     checkResultOverride = {
       decision: "prompt",
       reason: "Medium risk: requires approval",
     };
+    // The ladder is the gateway's; the daemon passes it through untouched.
+    classificationOverride = {
+      riskLevel: "medium",
+      reason: "npm install",
+      scopeOptions: [],
+      allowlistOptions: [
+        {
+          label: "npm install",
+          description: "Exact command",
+          pattern: "npm install",
+        },
+        {
+          label: "action:npm",
+          description: "Any npm command",
+          pattern: "action:npm",
+        },
+      ],
+      matchType: "registry",
+    };
 
     let capturedAllowlist: AllowlistOption[] | undefined;
     let capturedScopes: ScopeOption[] | undefined;
@@ -963,13 +988,11 @@ describe("integration regressions — prompt payload (PR 11)", () => {
       makeContext({ forcePromptSideEffects: true }),
     );
 
-    // Verify that the prompter received allowlist options
-    expect(capturedAllowlist).toBeDefined();
-    expect(capturedAllowlist!.length).toBeGreaterThan(0);
-    // The mock returns [{label: 'exact', description: 'exact', pattern: 'exact'}]
-    expect(capturedAllowlist![0]).toHaveProperty("pattern");
-    expect(capturedAllowlist![0]).toHaveProperty("label");
-    expect(capturedAllowlist![0]).toHaveProperty("description");
+    // The prompt offers exactly what the classifier produced, in order.
+    expect(capturedAllowlist?.map((o) => o.pattern)).toEqual([
+      "npm install",
+      "action:npm",
+    ]);
 
     // Verify scope options are also passed
     expect(capturedScopes).toBeDefined();
@@ -989,11 +1012,11 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
     getToolOverride = undefined;
     checkResultOverride = undefined;
     checkFnOverride = undefined;
-    cachedAssessmentOverride = undefined;
+    classificationOverride = undefined;
   });
 
   test("auto-approved tool result includes risk metadata when classifier assessment exists", async () => {
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "medium",
       reason: "Writes to a file outside the workspace",
       scopeOptions: [
@@ -1019,8 +1042,10 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
     ]);
   });
 
-  test("tool result omits risk metadata when no classifier assessment exists (e.g. MCP tools)", async () => {
-    // cachedAssessmentOverride is undefined (no classifier ran)
+  test("tool result carries the classification's risk metadata even when the classifier produced no options", async () => {
+    // classificationOverride is unset: the classifier answered low with no
+    // reason and no options, which is what a tool with no dedicated classifier
+    // (registry default risk) looks like.
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "file_read",
@@ -1029,9 +1054,9 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
     );
 
     expect(result.isError).toBe(false);
-    expect(result.riskLevel).toBeUndefined();
-    expect(result.riskReason).toBeUndefined();
-    expect(result.riskScopeOptions).toBeUndefined();
+    expect(result.riskLevel).toBe("low");
+    expect(result.riskScopeOptions).toEqual([]);
+    expect(result.riskAllowlistOptions).toBeUndefined();
   });
 
   test("denied tool result includes risk metadata", async () => {
@@ -1039,7 +1064,7 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
       decision: "deny",
       reason: "Blocked by deny rule",
     };
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "high",
       reason: "Recursive force delete",
       scopeOptions: [{ pattern: "bash:rm -rf*", label: "rm -rf commands" }],
@@ -1066,7 +1091,7 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
       decision: "prompt",
       reason: "Medium risk: requires approval",
     };
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "medium",
       reason: "Package manager installation",
       scopeOptions: [
@@ -1091,7 +1116,7 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
   });
 
   test("tool result includes riskDirectoryScopeOptions when classifier emits directoryScopeOptions", async () => {
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "medium",
       reason: "Writes to file in workspace",
       scopeOptions: [
@@ -1124,7 +1149,7 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
   });
 
   test("tool result omits riskDirectoryScopeOptions when classifier does not emit directoryScopeOptions", async () => {
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "low",
       reason: "Read-only operation",
       scopeOptions: [],
@@ -1144,7 +1169,7 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
   });
 
   test("riskScopeOptions and riskDirectoryScopeOptions are independent — one does not clobber the other", async () => {
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "medium",
       reason: "Filesystem write",
       scopeOptions: [
@@ -1170,7 +1195,7 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
   });
 
   test("auto-approved tool result includes riskAllowlistOptions when classifier emits them (Minimatch-glob shape for save path)", async () => {
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "medium",
       reason: "Reads workspace files",
       // Display ladder (regex shape — not for save).
@@ -1222,7 +1247,7 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
   });
 
   test("riskAllowlistOptions is undefined when classifier did not produce allowlist (e.g. web-risk classifier)", async () => {
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "low",
       reason: "GET request to public URL",
       scopeOptions: [
@@ -1248,8 +1273,8 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
     expect(result.riskAllowlistOptions).toBeUndefined();
   });
 
-  test("riskAllowlistOptions is undefined when no classifier ran (MCP tools)", async () => {
-    // cachedAssessmentOverride is undefined — no classifier ran.
+  test("riskAllowlistOptions is undefined when the classifier produced none", async () => {
+    // classificationOverride is unset: no allowlist options on the answer.
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "file_read",
@@ -1258,13 +1283,13 @@ describe("ToolExecutionResult includes risk metadata from classifier assessment"
     );
 
     expect(result.isError).toBe(false);
-    expect(result.riskScopeOptions).toBeUndefined();
+    expect(result.riskScopeOptions).toEqual([]);
     expect(result.riskAllowlistOptions).toBeUndefined();
   });
 
   test("denied tool result still carries riskAllowlistOptions for the rule editor save path", async () => {
     checkResultOverride = { decision: "deny", reason: "Blocked by deny rule" };
-    cachedAssessmentOverride = {
+    classificationOverride = {
       riskLevel: "high",
       reason: "Recursive force delete",
       scopeOptions: [{ pattern: "^rm\\s+-rf", label: "rm -rf *" }],
@@ -1334,7 +1359,7 @@ describe("ToolExecutor thrown-value rendering", () => {
     getAllToolsOverride = undefined;
     checkResultOverride = undefined;
     checkFnOverride = undefined;
-    cachedAssessmentOverride = undefined;
+    classificationOverride = undefined;
   });
 
   function throwingTool(name: string, thrown: unknown): void {
@@ -1406,7 +1431,7 @@ describe("ToolExecutor input-schema validation gate", () => {
     getAllToolsOverride = undefined;
     checkResultOverride = undefined;
     checkFnOverride = undefined;
-    cachedAssessmentOverride = undefined;
+    classificationOverride = undefined;
   });
 
   /**
@@ -1457,7 +1482,11 @@ describe("ToolExecutor input-schema validation gate", () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "file_read",
-      { path: "a.txt", offset: "not-a-number", activity: "Reading a file" },
+      {
+        path: "a.txt",
+        start_index: "not-a-number",
+        activity: "Reading a file",
+      },
       makeContext(),
     );
 

package/src/__tests__/turn-events-store.test.ts

@@ -331,3 +331,46 @@ describe("queryUnreportedTurnEvents", () => {
     expect(() => stampTurnOutcome("no-such-message", "failed")).not.toThrow();
   });
 });
+
+describe("unfinalized rows and turn accounting", () => {
+  test("an in-flight grouped tool-result row is not a real user turn", async () => {
+    const conv = createConversation({ conversationType: "standard" });
+    const first = await insertUserMessageAt(conv.id, "real question", 1000);
+    // The grouped tool-result row: user-role, reserved unfinalized while
+    // tool output streams, content a { ref } that does not contain the
+    // tool_result text the content exclusions match. Without the finalized
+    // predicate it counts as a phantom user turn until the fold.
+    const inflight = await insertUserMessageAt(
+      conv.id,
+      JSON.stringify({ ref: "conversations/conv/inflight/x.jsonl" }),
+      2000,
+    );
+    getDb().run(`UPDATE messages SET finalized = 0 WHERE id = '${inflight}'`);
+    const second = await insertUserMessageAt(conv.id, "second question", 3000);
+
+    const events = queryUnreportedTurnEvents(0, undefined, 100);
+    const ids = events
+      .filter((e) => e.conversationId === conv.id)
+      .map((e) => e.id);
+
+    expect(ids).toEqual([first, second]);
+    const byId = Object.fromEntries(events.map((e) => [e.id, e]));
+    expect(byId[first].turnIndex).toBe(1);
+    expect(byId[second].turnIndex).toBe(2);
+  });
+
+  test("a persisted empty-display user row still counts as a turn", async () => {
+    const conv = createConversation({ conversationType: "standard" });
+    const real = await insertUserMessageAt(conv.id, "real question", 1000);
+    // A hidden send persists its user row with [] content (displayContent "")
+    // and still runs a turn, so [] rows must stay in turn accounting.
+    const hidden = await insertUserMessageAt(conv.id, "[]", 2000);
+
+    const events = queryUnreportedTurnEvents(0, undefined, 100);
+    const ids = events
+      .filter((e) => e.conversationId === conv.id)
+      .map((e) => e.id);
+
+    expect(ids).toEqual([real, hidden]);
+  });
+});

package/src/__tests__/ui-choice-copy-surfaces.test.ts

@@ -22,7 +22,7 @@ import { asConversation } from "./helpers/mock-conversation.js";
 function makeContext(sent: AssistantEvent[] = []): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,

package/src/__tests__/ui-shape-teaching.test.ts

@@ -5,6 +5,7 @@ import { uiShowTool } from "../tools/ui-surface/definitions.js";
 import {
   SURFACE_SHAPE_DOCS,
   SURFACE_TYPE_NAMES,
+  UI_SHOW_TYPE_DOCS,
   uiShowTeachingError,
 } from "../tools/ui-surface/surface-shape-docs.js";
 
@@ -290,6 +291,12 @@ describe("ui_show displayable payloads proxy through", () => {
         surfaceType: "channel_setup",
         input: { surface_type: "channel_setup", data: { channel: "telegram" } },
       },
+      {
+        // The picker reads its own voice and catalog, so an empty payload is
+        // the whole contract and there is no missing-content state to teach.
+        surfaceType: "voice_picker",
+        input: { surface_type: "voice_picker", data: {} },
+      },
     ];
 
   for (const { surfaceType, input } of cases) {
@@ -347,4 +354,30 @@ describe("uiShowTeachingError", () => {
       expect(uiShowTool.description).toContain(name);
     }
   });
+
+  test("voice_picker is a cold type that accepts an empty payload", () => {
+    expect(
+      uiShowTeachingError({ surface_type: "voice_picker", data: {} }),
+    ).toBeNull();
+    expect(UI_SHOW_TYPE_DOCS).toContain(
+      `voice_picker (${SURFACE_SHAPE_DOCS.voice_picker!.purpose})`,
+    );
+    expect(UI_SHOW_TYPE_DOCS).not.toContain("- voice_picker:");
+  });
+
+  test("voice_picker steering reaches the model through the cold index", () => {
+    // Asserted on the built description rather than the doc entry: a cold
+    // type's `shape` reaches the model only through a teaching error, and an
+    // empty payload has no missing-content state to raise one, so steering
+    // parked there would be dead.
+    for (const directive of [
+      "change, hear, or pick a voice",
+      "rather than describing voices in prose",
+      "attach no actions and never set await_action",
+      "during a live voice call answer in speech",
+    ]) {
+      expect(UI_SHOW_TYPE_DOCS).toContain(directive);
+      expect(uiShowTool.description).toContain(directive);
+    }
+  });
 });

package/src/__tests__/ui-visual-surface.test.ts

@@ -32,7 +32,7 @@ const HTML = '<div style="color:var(--content-default)">Hello</div>';
 function makeContext(sent: AssistantEvent[] = []): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,