@vellumai/assistant 0.12.2-staging.3 → 0.12.2-staging.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-staging.3",
+  "version": "0.12.2-staging.5",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/acp/session-snapshot.ts

@@ -0,0 +1,260 @@
+import { desc, eq } from "drizzle-orm";
+
+import { getDb } from "../persistence/db-connection.js";
+import { acpSessionHistory } from "../persistence/schema/index.js";
+import { getLogger } from "../util/logger.js";
+import { acpAuthMarkerStillCurrent } from "./acp-auth-marker-store.js";
+import { getAcpSessionManager } from "./index.js";
+import type { AcpSessionManager } from "./session-manager.js";
+import type { AcpSessionState } from "./types.js";
+
+const log = getLogger("acp:session-snapshot");
+
+export interface AcpSessionSnapshot {
+  id: string;
+  agentId: string;
+  acpSessionId: string;
+  parentConversationId: string;
+  status: string;
+  startedAt: number;
+  completedAt?: number | null;
+  error?: string | null;
+  stopReason?: string | null;
+  task?: string;
+  parentToolUseId?: string;
+  authErrorCode?: string;
+  authErrorCredential?: string;
+  model?: string;
+  availableModels?: AcpSessionState["availableModels"];
+  modelRevisionEpoch?: string;
+  modelRevision?: number;
+  usedTokens?: number;
+  contextSize?: number;
+  costAmount?: number;
+  costCurrency?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  eventLog?: unknown[];
+  source: "live" | "history";
+  resumable: boolean;
+  cwd?: string | null;
+}
+
+export interface AcpSessionSnapshotPage {
+  sessions: AcpSessionSnapshot[];
+  sawEveryHistoryRow: boolean;
+}
+
+interface SnapshotOptions {
+  includeEventLog?: boolean;
+}
+
+function fromLiveState(
+  state: AcpSessionState,
+  manager: AcpSessionManager,
+  opts: SnapshotOptions,
+): AcpSessionSnapshot {
+  return {
+    id: state.id,
+    agentId: state.agentId,
+    acpSessionId: state.acpSessionId,
+    parentConversationId: state.parentConversationId,
+    status: state.status,
+    startedAt: state.startedAt,
+    completedAt: state.completedAt ?? null,
+    error: state.error ?? null,
+    stopReason: state.stopReason ?? null,
+    task: state.task,
+    parentToolUseId: state.parentToolUseId,
+    authErrorCode: state.authErrorCode,
+    authErrorCredential: state.authErrorCredential,
+    model: state.model,
+    availableModels: state.availableModels,
+    modelRevisionEpoch: state.modelRevisionEpoch,
+    modelRevision: state.modelRevision,
+    usedTokens: state.latestUsage?.usedTokens,
+    contextSize: state.latestUsage?.contextSize,
+    costAmount: state.latestUsage?.costAmount,
+    costCurrency: state.latestUsage?.costCurrency,
+    inputTokens: state.latestUsage?.inputTokens,
+    outputTokens: state.latestUsage?.outputTokens,
+    eventLog: opts.includeEventLog
+      ? manager.getBufferedUpdates(state.id)
+      : undefined,
+    source: "live",
+    resumable: false,
+  };
+}
+
+function isResumableHistoryRow(
+  row: typeof acpSessionHistory.$inferSelect,
+): boolean {
+  return Boolean(row.cwd && row.acpSessionId);
+}
+
+export function snapshotHistoryRow(
+  row: typeof acpSessionHistory.$inferSelect,
+  opts: SnapshotOptions = { includeEventLog: true },
+): AcpSessionSnapshot {
+  let eventLog: unknown[] | undefined;
+  if (opts.includeEventLog !== false) {
+    eventLog = [];
+    try {
+      const parsed = JSON.parse(row.eventLogJson) as unknown;
+      if (Array.isArray(parsed)) {
+        eventLog = parsed;
+      }
+    } catch (err) {
+      log.warn(
+        { id: row.id, err },
+        "Failed to parse event_log_json for ACP session history row",
+      );
+    }
+  }
+
+  return {
+    id: row.id,
+    agentId: row.agentId,
+    acpSessionId: row.acpSessionId,
+    parentConversationId: row.parentConversationId,
+    status: row.status,
+    startedAt: row.startedAt,
+    completedAt: row.completedAt,
+    error: row.error,
+    stopReason: row.stopReason,
+    task: row.task ?? undefined,
+    parentToolUseId: row.parentToolUseId ?? undefined,
+    authErrorCode: row.authErrorCode ?? undefined,
+    authErrorCredential: row.authErrorCredential ?? undefined,
+    usedTokens: row.usedTokens ?? undefined,
+    contextSize: row.contextSize ?? undefined,
+    costAmount: row.costAmount ?? undefined,
+    costCurrency: row.costCurrency ?? undefined,
+    inputTokens: row.inputTokens ?? undefined,
+    outputTokens: row.outputTokens ?? undefined,
+    eventLog,
+    source: "history",
+    resumable: isResumableHistoryRow(row),
+    cwd: row.cwd,
+  };
+}
+
+/**
+ * Blank `authErrorCode` on any session whose marker no longer describes the
+ * credential its agent would resolve.
+ *
+ * This comparison is what retires a Connect card: the marker no longer
+ * describing the credential in use. Applied after merging rather than inside
+ * the query, so live sessions and history rows are judged by the same rule.
+ *
+ * Resolved per agent and memoised across the batch, because precedence is per
+ * agent and each resolution costs a vault read.
+ */
+export async function withCurrentAuthMarkers<
+  T extends {
+    agentId: string;
+    authErrorCode?: string;
+    authErrorCredential?: string;
+  },
+>(
+  sessions: readonly T[],
+  resolvedFor: (agentId: string) => Promise<string | undefined>,
+): Promise<T[]> {
+  if (!sessions.some((session) => session.authErrorCode !== undefined)) {
+    return [...sessions];
+  }
+  const resolvedByAgent = new Map<string, string | undefined>();
+  const resolve = async (agentId: string) => {
+    if (!resolvedByAgent.has(agentId)) {
+      resolvedByAgent.set(agentId, await resolvedFor(agentId));
+    }
+    return resolvedByAgent.get(agentId);
+  };
+  const judged: T[] = [];
+  for (const session of sessions) {
+    if (session.authErrorCode === undefined) {
+      judged.push(session);
+      continue;
+    }
+    const current = acpAuthMarkerStillCurrent(
+      session.authErrorCredential,
+      await resolve(session.agentId),
+    );
+    judged.push(
+      current ? session : { ...session, authErrorCode: undefined },
+    );
+  }
+  return judged;
+}
+
+export function getAcpSessionSnapshot(
+  acpSessionId: string,
+  opts: SnapshotOptions = {},
+): AcpSessionSnapshot | undefined {
+  const manager = getAcpSessionManager();
+  const snapshotOptions = {
+    includeEventLog: opts.includeEventLog ?? true,
+  };
+  const live = (manager.getStatus() as AcpSessionState[]).find(
+    (state) => state.id === acpSessionId,
+  );
+  if (live) {
+    return fromLiveState(live, manager, snapshotOptions);
+  }
+
+  const row = getDb()
+    .select()
+    .from(acpSessionHistory)
+    .where(eq(acpSessionHistory.id, acpSessionId))
+    .get();
+  return row ? snapshotHistoryRow(row, snapshotOptions) : undefined;
+}
+
+export function listAcpSessionSnapshots(opts: {
+  limit: number;
+  conversationId?: string;
+  includeEventLog?: boolean;
+}): AcpSessionSnapshotPage {
+  const manager = getAcpSessionManager();
+  const inMemory = manager.getStatus() as AcpSessionState[];
+  const snapshotOptions = {
+    includeEventLog: opts.includeEventLog ?? true,
+  };
+
+  const merged = new Map<string, AcpSessionSnapshot>();
+  for (const state of inMemory) {
+    if (
+      opts.conversationId &&
+      state.parentConversationId !== opts.conversationId
+    ) {
+      continue;
+    }
+    merged.set(state.id, fromLiveState(state, manager, snapshotOptions));
+  }
+
+  const db = getDb();
+  const baseQuery = db.select().from(acpSessionHistory);
+  const filtered = opts.conversationId
+    ? baseQuery.where(
+        eq(acpSessionHistory.parentConversationId, opts.conversationId),
+      )
+    : baseQuery;
+  const historyLimit = opts.limit + merged.size;
+  const historyRows = filtered
+    .orderBy(desc(acpSessionHistory.startedAt))
+    .limit(historyLimit)
+    .all();
+
+  for (const row of historyRows) {
+    if (!merged.has(row.id)) {
+      merged.set(row.id, snapshotHistoryRow(row, snapshotOptions));
+    }
+  }
+
+  return {
+    sessions: Array.from(merged.values()).sort(
+      (a, b) => b.startedAt - a.startedAt,
+    ),
+    sawEveryHistoryRow: historyRows.length < historyLimit,
+  };
+}

package/src/config/bundled-skills/acp/SKILL.md

@@ -125,5 +125,5 @@ Default to the conversation's current working directory when spawning an agent.
 
 - The spawned agent runs autonomously with its own tools, file editing, and terminal access.
 - Results are streamed back and injected into the conversation when the agent completes.
-- Use `acp_status` to check on running agents and `acp_abort` to stop them.
+- Use `acp_status` to inspect running and idle agents. Use `acp_steer` to attempt follow-up work on an idle session; do not replace it with a new `acp_spawn`.
 - The `cwd` parameter controls where the agent works - set it to the project root the user wants the agent to operate in.

package/src/config/bundled-skills/acp/TOOLS.json

@@ -33,7 +33,7 @@
     },
     {
       "name": "acp_status",
-      "description": "Get the status of a specific ACP session or list all ACP sessions. Only use this when the user explicitly asks about ACP session status - do NOT poll automatically, as you will be notified when sessions complete.",
+      "description": "Get the status of a specific ACP session or list recent ACP sessions. Cleanly completed sessions with durable resume metadata are returned as idle; use `acp_steer` to attempt follow-up work on them instead of starting over with `acp_spawn`. Only use this when the user explicitly asks about ACP session status - do NOT poll automatically, as you will be notified when sessions complete.",
       "category": "orchestration",
       "risk": "low",
       "input_schema": {
@@ -41,7 +41,7 @@
         "properties": {
           "acp_session_id": {
             "type": "string",
-            "description": "Optional ACP session ID to query. If omitted, returns all ACP sessions."
+            "description": "Optional ACP session ID to query. If omitted, returns recent ACP sessions, including active and resumable idle sessions."
           }
         },
         "required": []

package/src/config/bundled-skills/skill-management/TOOLS.json

@@ -118,7 +118,7 @@
     },
     {
       "name": "find_similar_skills",
-      "description": "Find the existing skills most similar to a goal. Scores the goal against the skill catalog's capability pages and returns a ranked shortlist of nearest skills, each with its name, description, source (bundled, managed, plugin, workspace, or extra), and similarity score. For a managed hit it also returns `author` — \"assistant\" if the assistant authored that skill (so it may be overwritten) or \"user\" if a person did (off-limits); `author` is omitted for non-managed sources and for managed skills with no recorded author. Read-only — it never creates, edits, or deletes anything.",
+      "description": "Find the existing skills most similar to a goal. Scores the goal against the skill catalog's capability pages and returns a ranked shortlist of nearest skills, each with its name, description, source (bundled, managed, plugin, workspace, or extra), and similarity score. For a managed hit it also returns `author`: \"assistant\" if the assistant authored that skill (so it may be overwritten) or \"user\" if a person did (off-limits); `author` is omitted for non-managed sources and for managed skills with no recorded author. For a background memory pass, a hit it may refine (managed, assistant-authored) also carries `current`: the skill as it is now, in scaffold_managed_skill's own argument names (name, description, emoji, category, includes, activation_hints, avoid_when, body_markdown), so a refinement can be written from the real skill and carry forward what it is not changing. Read-only: it never creates, edits, or deletes anything.",
       "category": "skills",
       "risk": "low",
       "input_schema": {

package/src/live-voice/__tests__/live-voice-look-follow-up.test.ts

@@ -0,0 +1,374 @@
+/**
+ * Answering a look (`[LOOK:SCREEN]`, `[LOOK:CAMERA]`) on a turn of its own.
+ *
+ * The reply that asks for a look only acknowledges it. A client that declared
+ * `lookFrames` sends a fresh frame once it has carried the look out, and the
+ * session answers from that frame without waiting for the user to speak again.
+ * Without the declaration, or without the frame, nothing extra runs.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+import {
+  createMockProvider,
+  textResponse,
+} from "../../__tests__/helpers/mock-provider.js";
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+import { waitFor } from "../../__tests__/helpers/wait-for.js";
+
+setConfig("memory", { enabled: false });
+
+import type {
+  VoiceTurnCallbacks,
+  VoiceTurnOptions,
+} from "../../calls/voice-session-bridge.js";
+import { Conversation } from "../../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../../daemon/conversation-registry.js";
+import { uploadAttachment } from "../../persistence/attachments-store.js";
+import {
+  createConversation,
+  getMessages,
+} from "../../persistence/conversation-crud.js";
+import { initializeDb } from "../../persistence/db-init.js";
+import type {
+  StreamingTranscriber,
+  SttStreamServerEvent,
+} from "../../stt/types.js";
+import {
+  LiveVoiceSession,
+  type LiveVoiceTtsStreamer,
+} from "../live-voice-session.js";
+import type { LiveVoiceSessionFactoryContext } from "../live-voice-session-manager.js";
+import type { LiveVoiceTtsOptions } from "../live-voice-tts.js";
+import {
+  createLiveVoiceServerFrameSequencer,
+  type LiveVoiceServerFrame,
+} from "../protocol.js";
+import {
+  LOOK_FOLLOW_UP_CONTENT,
+  LOOK_FRAME_REASON,
+} from "../session-controls.js";
+
+await initializeDb();
+
+const IMAGE_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk";
+
+/** Hands over one spoken sentence each time a capture is released. */
+class MockStreamingTranscriber implements StreamingTranscriber {
+  readonly providerId = "deepgram" as const;
+  readonly boundaryId = "daemon-streaming" as const;
+  private onEvent: ((event: SttStreamServerEvent) => void) | null = null;
+
+  async start(onEvent: (event: SttStreamServerEvent) => void): Promise<void> {
+    this.onEvent = onEvent;
+  }
+
+  sendAudio(): void {}
+
+  stop(): void {
+    this.onEvent?.({ type: "final", text: "look at my screen" });
+    this.onEvent?.({ type: "closed" });
+  }
+}
+
+function createHarness(options: { lookFrames: boolean }) {
+  const conversation = createConversation("Look follow-up");
+  const { provider } = createMockProvider([textResponse("")]);
+  const activeConversation = new Conversation(
+    conversation.id,
+    provider,
+    "system prompt",
+    () => {},
+    "/tmp",
+    { maxTokens: 4096 },
+  );
+  activeConversation.setTrustContext({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  });
+  setConversation(conversation.id, activeConversation);
+
+  const sequencer = createLiveVoiceServerFrameSequencer();
+  const frames: LiveVoiceServerFrame[] = [];
+  const context: LiveVoiceSessionFactoryContext = {
+    sessionId: "session-look",
+    startFrame: {
+      type: "start",
+      conversationId: conversation.id,
+      audio: { mimeType: "audio/pcm", sampleRate: 24_000, channels: 1 },
+      textInput: true,
+      sessionControls: ["look_screen", "look_camera", "look_stop"],
+      ...(options.lookFrames ? { lookFrames: true } : {}),
+    },
+    sendFrame: mock(async (payload) => {
+      const frame = sequencer.next(payload);
+      frames.push(frame);
+      return frame;
+    }),
+  };
+
+  const turns: VoiceTurnOptions[] = [];
+  const startVoiceTurn = mock(async (turnOptions: VoiceTurnOptions) => {
+    turns.push(turnOptions);
+    return { turnId: `bridge-turn-${turns.length}`, abort: mock() };
+  });
+  const streamTtsAudio: LiveVoiceTtsStreamer = mock(
+    async (ttsOptions: LiveVoiceTtsOptions) => ({
+      provider: "fish-audio" as const,
+      contentType: "audio/pcm",
+      sampleRate: 24_000,
+      chunks: 1,
+      bytes: Buffer.byteLength(ttsOptions.text),
+    }),
+  );
+
+  let turnCount = 0;
+  const session = new LiveVoiceSession(context, {
+    resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
+    startVoiceTurn,
+    streamTtsAudio,
+    createTurnId: () => `live-turn-${++turnCount}`,
+    emitMetrics: false,
+  });
+
+  const callbacks = (index: number): VoiceTurnCallbacks | undefined =>
+    turns[index]?.callbacks;
+
+  /** Finish turn `index` with `text` and wait for its speech to drain. */
+  const reply = async (index: number, text: string): Promise<void> => {
+    const turnCallbacks = callbacks(index);
+    turnCallbacks?.assistant_text_delta?.({
+      type: "assistant_text_delta",
+      text,
+      conversationId: conversation.id,
+    });
+    turnCallbacks?.message_complete?.({
+      type: "message_complete",
+      conversationId: conversation.id,
+      messageId: `assistant-message-${index}`,
+    });
+    const doneCount = index + 1;
+    await waitFor(
+      () =>
+        frames.filter((frame) => frame.type === "tts_done").length >= doneCount,
+      { message: `Timed out waiting for turn ${index} to drain` },
+    );
+  };
+
+  /** Ask for a look, and wait for the control to reach the client. */
+  const askForLook = async (): Promise<void> => {
+    await session.start();
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => turns.length === 1, {
+      message: "Timed out waiting for the spoken turn",
+    });
+    await reply(0, "Taking a look. [LOOK:SCREEN]");
+    await waitFor(
+      () => frames.some((frame) => frame.type === "session_control"),
+      { message: "Timed out waiting for the look control" },
+    );
+  };
+
+  /** Send a real kept frame with the given timing reason. */
+  const sendFrame = async (reason: string): Promise<void> => {
+    const attachment = await uploadAttachment(
+      "frame.png",
+      "image/png",
+      IMAGE_BASE64,
+    );
+    const before = getMessages(conversation.id).length;
+    await session.handleClientFrame({
+      type: "sight_frame",
+      attachmentId: attachment.id,
+      timing: {
+        reason,
+        keepToEncodedMs: 1,
+        encodedToUploadedMs: 1,
+        uploadedToSentMs: 0,
+        bytes: 1,
+      },
+    });
+    await waitFor(() => getMessages(conversation.id).length > before, {
+      message: "Timed out waiting for the frame to persist",
+    });
+  };
+
+  return {
+    frames,
+    session,
+    turns,
+    reply,
+    askForLook,
+    sendFrame,
+    dispose: async () => {
+      await session.close("client_end");
+      deleteConversation(conversation.id);
+      activeConversation.dispose();
+    },
+  };
+}
+
+/** Long enough for a follow-up that was going to start to have started. */
+async function settle(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 600));
+}
+
+describe("live-voice look follow-up", () => {
+  test("answers the look from its frame on a hidden turn of its own", async () => {
+    const harness = createHarness({ lookFrames: true });
+    try {
+      await harness.askForLook();
+      expect(harness.turns).toHaveLength(1);
+
+      await harness.sendFrame(LOOK_FRAME_REASON);
+      await waitFor(() => harness.turns.length === 2, {
+        message: "Timed out waiting for the look to be answered",
+      });
+
+      const followUp = harness.turns[1];
+      expect(followUp?.content).toBe(LOOK_FOLLOW_UP_CONTENT);
+      expect(followUp?.hiddenSyntheticPrompt).toBe(true);
+      expect(followUp?.voiceControlPrompt).toContain(
+        "You just took a fresh look at their screen",
+      );
+    } finally {
+      await harness.dispose();
+    }
+  });
+
+  test("the reply that asks for a look is taught to only acknowledge it", async () => {
+    const harness = createHarness({ lookFrames: true });
+    try {
+      await harness.askForLook();
+      expect(harness.turns[0]?.voiceControlPrompt).toContain(
+        "Use it even when their screen is already shared with you",
+      );
+    } finally {
+      await harness.dispose();
+    }
+  });
+
+  test("a client that did not declare lookFrames keeps the old look", async () => {
+    const harness = createHarness({ lookFrames: false });
+    try {
+      await harness.askForLook();
+      expect(harness.turns[0]?.voiceControlPrompt).toContain(
+        "say you will take it from their next words",
+      );
+
+      await harness.sendFrame(LOOK_FRAME_REASON);
+      await settle();
+      expect(harness.turns).toHaveLength(1);
+    } finally {
+      await harness.dispose();
+    }
+  });
+
+  test("an ambient frame does not answer the look", async () => {
+    const harness = createHarness({ lookFrames: true });
+    try {
+      await harness.askForLook();
+      await harness.sendFrame("heartbeat");
+      await settle();
+      expect(harness.turns).toHaveLength(1);
+    } finally {
+      await harness.dispose();
+    }
+  });
+
+  // The turn started before the frame was in the conversation, so it could
+  // not have read it: the look is still owed an answer once that turn is done.
+  test("a turn that started before the frame landed does not answer the look", async () => {
+    const harness = createHarness({ lookFrames: true });
+    try {
+      await harness.askForLook();
+      await harness.session.handleClientFrame({
+        type: "text",
+        text: "the second dropdown",
+      });
+      await waitFor(() => harness.turns.length === 2, {
+        message: "Timed out waiting for the typed turn",
+      });
+
+      await harness.sendFrame(LOOK_FRAME_REASON);
+      await harness.reply(1, "Which one do you mean?");
+      await waitFor(() => harness.turns.length === 3, {
+        timeoutMs: 2_000,
+        message: "Timed out waiting for the look to be answered",
+      });
+      expect(harness.turns[2]?.content).toBe(LOOK_FOLLOW_UP_CONTENT);
+    } finally {
+      await harness.dispose();
+    }
+  });
+
+  test("a turn that starts after the frame landed is not answered twice", async () => {
+    const harness = createHarness({ lookFrames: true });
+    try {
+      await harness.askForLook();
+      await harness.session.handleClientFrame({
+        type: "text",
+        text: "the second dropdown",
+      });
+      await waitFor(() => harness.turns.length === 2, {
+        message: "Timed out waiting for the typed turn",
+      });
+
+      // Lands while the typed turn holds the floor, so the look waits.
+      await harness.sendFrame(LOOK_FRAME_REASON);
+      await harness.reply(1, "Which one do you mean?");
+      // The user's next turn starts before the look's wait checks again, and
+      // it reads the frame that is now in the conversation.
+      await harness.session.handleClientFrame({
+        type: "text",
+        text: "the plan picker",
+      });
+      await waitFor(() => harness.turns.length === 3, {
+        message: "Timed out waiting for the second typed turn",
+      });
+      await harness.reply(2, "That one sets the billing plan.");
+      await settle();
+
+      expect(harness.turns).toHaveLength(3);
+      expect(harness.turns[2]?.content).toBe("the plan picker");
+    } finally {
+      await harness.dispose();
+    }
+  });
+
+  test("an interrupt drops a look still waiting on its frame", async () => {
+    const harness = createHarness({ lookFrames: true });
+    try {
+      await harness.askForLook();
+      await harness.session.handleClientFrame({ type: "interrupt" });
+
+      await harness.sendFrame(LOOK_FRAME_REASON);
+      await settle();
+      expect(harness.turns).toHaveLength(1);
+    } finally {
+      await harness.dispose();
+    }
+  });
+
+  test("the turn that answers a look cannot chain another look", async () => {
+    const harness = createHarness({ lookFrames: true });
+    try {
+      await harness.askForLook();
+      await harness.sendFrame(LOOK_FRAME_REASON);
+      await waitFor(() => harness.turns.length === 2, {
+        message: "Timed out waiting for the look to be answered",
+      });
+
+      await harness.reply(1, "It is the plan picker. [LOOK:SCREEN]");
+      await harness.sendFrame(LOOK_FRAME_REASON);
+      await settle();
+      expect(harness.turns).toHaveLength(2);
+    } finally {
+      await harness.dispose();
+    }
+  });
+});