@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/notifications/__tests__/emit-signal-home-feed.test.ts

@@ -1,187 +0,0 @@
-/**
- * Verifies that `emitNotificationSignal` invokes the home-feed side
- * effect after dispatching, and that the side effect's background-only
- * filter correctly suppresses interactive signals.
- *
- * The side effect itself is unit-tested in `home-feed-side-effect.test.ts`;
- * this test exercises the wire-up boundary in `emit-signal.ts` by mocking
- * at the `appendFeedItem` / `getConversation` boundary so the real
- * background-filter logic runs end-to-end.
- */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { FeedItem } from "../../home/feed-types.js";
-import type {
-  NotificationDecision,
-  NotificationDeliveryResult,
-} from "../types.js";
-
-// ── Module mocks ───────────────────────────────────────────────────────
-//
-// `mock.module` is hoisted, so these intercepts apply before the module
-// under test resolves its imports. Closures over module-scoped state
-// let each test reset and inspect captured calls afterwards.
-
-const appendCalls: FeedItem[] = [];
-let conversationRow: { conversationType: string } | null = null;
-
-mock.module("../../home/feed-writer.js", () => ({
-  appendFeedItem: async (item: FeedItem) => {
-    appendCalls.push(item);
-  },
-}));
-
-// home-feed-side-effect.ts only consumes `getConversation`.
-mock.module("../../memory/conversation-crud.js", () => ({
-  getConversation: () => conversationRow,
-  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
-}));
-
-// Stub the broadcaster so emit-signal's `getBroadcaster()` does not need
-// to build real adapters or pull in `conversation-pairing.ts` transitively
-// (which would force us to mirror the full `conversation-crud.js` surface).
-class StubBroadcaster {
-  setOnConversationCreated() {}
-  async broadcastDecision() {
-    return [];
-  }
-}
-mock.module("../broadcaster.js", () => ({
-  NotificationBroadcaster: StubBroadcaster,
-}));
-
-mock.module("../adapters/macos.js", () => ({
-  VellumAdapter: class {},
-  isGuardianSensitiveEvent: () => false,
-}));
-mock.module("../adapters/slack.js", () => ({
-  SlackAdapter: class {},
-}));
-mock.module("../adapters/telegram.js", () => ({
-  TelegramAdapter: class {},
-}));
-
-// Stub out the persistence + channel resolution layers so emitNotificationSignal
-// can run end-to-end without touching the DB / contacts store / LLM.
-
-mock.module("../events-store.js", () => ({
-  createEvent: (params: { id: string }) => ({
-    id: params.id,
-    sourceEventName: "schedule.notify",
-    sourceChannel: "scheduler",
-    sourceContextId: "conv-source-1",
-    attentionHintsJson: "{}",
-    payloadJson: "{}",
-    dedupeKey: null,
-    createdAt: 0,
-    updatedAt: 0,
-  }),
-  updateEventDedupeKey: () => {},
-}));
-
-mock.module("../decisions-store.js", () => ({
-  updateDecision: () => {},
-}));
-
-mock.module("../../contacts/contact-store.js", () => ({
-  findGuardianForChannel: () => null,
-  listGuardianChannels: () => [],
-}));
-
-const stubDecision: NotificationDecision = {
-  shouldNotify: true,
-  selectedChannels: ["vellum"],
-  reasoningSummary: "test",
-  renderedCopy: {
-    vellum: { title: "Background job done", body: "Summary of what happened." },
-  },
-  dedupeKey: "dk-1",
-  confidence: 1,
-  fallbackUsed: false,
-};
-
-mock.module("../decision-engine.js", () => ({
-  evaluateSignal: async () => stubDecision,
-  // Pass the decision through unchanged — emit-signal calls this after
-  // evaluateSignal and only re-persists when the reference changes.
-  enforceRoutingIntent: (decision: NotificationDecision) => decision,
-}));
-
-mock.module("../deterministic-checks.js", () => ({
-  runDeterministicChecks: async () => ({ passed: true }),
-}));
-
-const stubDeliveryResults: NotificationDeliveryResult[] = [
-  {
-    channel: "vellum",
-    destination: "vellum-client",
-    status: "sent",
-    conversationId: "conv-vellum-1",
-  },
-];
-
-mock.module("../runtime-dispatch.js", () => ({
-  dispatchDecision: async () => ({
-    dispatched: true,
-    reason: "Dispatched to 1/1 channels",
-    deliveryResults: stubDeliveryResults,
-  }),
-}));
-
-const { emitNotificationSignal } = await import("../emit-signal.js");
-
-// ── Tests ──────────────────────────────────────────────────────────────
-
-beforeEach(() => {
-  appendCalls.length = 0;
-  conversationRow = null;
-});
-
-describe("emitNotificationSignal home-feed wire-up", () => {
-  test("background-conversation signal triggers appendFeedItem", async () => {
-    conversationRow = { conversationType: "background" };
-
-    const result = await emitNotificationSignal({
-      sourceEventName: "schedule.notify",
-      sourceChannel: "scheduler",
-      sourceContextId: "conv-source-1",
-      contextPayload: { title: "Background job done" },
-      attentionHints: {
-        requiresAction: false,
-        urgency: "medium",
-        isAsyncBackground: false,
-        visibleInSourceNow: false,
-      },
-    });
-
-    expect(result.dispatched).toBe(true);
-    expect(appendCalls).toHaveLength(1);
-    const appended = appendCalls[0]!;
-    expect(appended.id).toBe(`notif:${result.signalId}`);
-    expect(appended.title).toBe("Background job done");
-    expect(appended.summary).toBe("Summary of what happened.");
-    // The feed item's conversationId points to the source conversation
-    // that emitted the signal, not the conversation the notification
-    // pipeline spawned to handle it.
-    expect(appended.conversationId).toBe("conv-source-1");
-  });
-
-  test("interactive standard conversation does NOT trigger appendFeedItem", async () => {
-    conversationRow = { conversationType: "standard" };
-
-    const result = await emitNotificationSignal({
-      sourceEventName: "schedule.notify",
-      sourceChannel: "scheduler",
-      sourceContextId: "conv-source-1",
-      attentionHints: {
-        requiresAction: false,
-        urgency: "medium",
-        isAsyncBackground: false,
-        visibleInSourceNow: true,
-      },
-    });
-
-    expect(result.dispatched).toBe(true);
-    expect(appendCalls).toHaveLength(0);
-  });
-});

package/src/plugins/defaults/memory-v3-shadow/__tests__/fixtures/eval-turns.json

@@ -1,36 +0,0 @@
-{
-  "_comment": "Synthetic, generic eval turns for the memory-v3 orchestrator. No real content. Domains/slugs are placeholders (domain-a/topic-x, page-a). Each turn names which leaves L1 should open and which page IDs L2 should select per opened leaf; expectedFinalInjection is the orchestrator's deduped slug list for that turn given a SHARED working set across the sequence.",
-  "turns": [
-    {
-      "name": "turn 1 — open topic-x, select page-a (pinned) and page-b",
-      "currentMessage": "tell me about page a",
-      "routeIds": [1],
-      "leafSelections": {
-        "domain-a/topic-x": { "ids": [1, 2], "pinned_ids": [1] }
-      },
-      "expectedOpenedLeaves": ["domain-a/topic-x"],
-      "expectedFinalInjection": ["page-a", "page-b"]
-    },
-    {
-      "name": "turn 2 — open topic-y, select page-c; page-a carries forward (pinned)",
-      "currentMessage": "now about page c",
-      "routeIds": [2],
-      "leafSelections": {
-        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
-      },
-      "expectedOpenedLeaves": ["domain-a/topic-y"],
-      "expectedFinalInjection": ["page-c", "page-a", "page-b"]
-    },
-    {
-      "name": "turn 3 — open both leaves, select page-b and page-c",
-      "currentMessage": "compare page b and page c",
-      "routeIds": [1, 2],
-      "leafSelections": {
-        "domain-a/topic-x": { "ids": [2], "pinned_ids": [] },
-        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
-      },
-      "expectedOpenedLeaves": ["domain-a/topic-x", "domain-a/topic-y"],
-      "expectedFinalInjection": ["page-b", "page-c", "page-a"]
-    }
-  ]
-}

package/src/plugins/defaults/memory-v3-shadow/__tests__/fixtures/live-turns.json

@@ -1,37 +0,0 @@
-{
-  "_comment": "Synthetic, generic turns for the memory-v3 LIVE-injection integration test. No real content. The tree has two leaves (domain-a/topic-x → [page-a, page-b], domain-a/topic-y → [page-c]); L1 id 1 → topic-x, id 2 → topic-y. Each turn names which leaves L1 opens and which page IDs L2 selects (and pins) per opened leaf. Driven through a SHARED WorkingSet across the sequence so carry-forward and window eviction are exercised end-to-end. The WorkingSet uses a small evictWindow so a non-pinned page selected only in turn 1 ages out by a later turn while a pinned page persists.",
-  "turns": [
-    {
-      "name": "turn 1 — open topic-x, select page-a (pinned) + page-b (unpinned)",
-      "currentMessage": "tell me about page a",
-      "routeIds": [1],
-      "leafSelections": {
-        "domain-a/topic-x": { "ids": [1, 2], "pinned_ids": [1] }
-      }
-    },
-    {
-      "name": "turn 2 — open topic-y, select page-c; page-a + page-b carry forward",
-      "currentMessage": "now about page c",
-      "routeIds": [2],
-      "leafSelections": {
-        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
-      }
-    },
-    {
-      "name": "turn 3 — open topic-y again, re-select page-c (refreshes its lastSeen)",
-      "currentMessage": "more on page c",
-      "routeIds": [2],
-      "leafSelections": {
-        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
-      }
-    },
-    {
-      "name": "turn 4 — open topic-y, re-select page-c; page-b now stale enough to age out",
-      "currentMessage": "still page c",
-      "routeIds": [2],
-      "leafSelections": {
-        "domain-a/topic-y": { "ids": [1], "pinned_ids": [] }
-      }
-    }
-  ]
-}

package/src/plugins/defaults/memory-v3-shadow/__tests__/working-set-eviction.test.ts

@@ -1,106 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { WorkingSetEntry } from "../types.js";
-import { ScoreFn, WorkingSet } from "../working-set.js";
-
-describe("WorkingSet.evict", () => {
-  test("evicts a page unseen past the window", () => {
-    const ws = new WorkingSet(150, 5);
-    ws.recordSelection("alpha", 0, false);
-
-    // currentTurn 6, lastSeen 0 → gap 6 > window 5 → evict.
-    ws.evict(6, new Set());
-
-    expect(ws.union().has("alpha")).toBe(false);
-    expect(ws.size()).toBe(0);
-  });
-
-  test("keeps a page still inside the window", () => {
-    const ws = new WorkingSet(150, 5);
-    ws.recordSelection("alpha", 0, false);
-
-    // gap 5 is not > 5 → keep.
-    ws.evict(5, new Set());
-
-    expect(ws.union().has("alpha")).toBe(true);
-  });
-
-  test("pinned page never evicts past the window", () => {
-    const ws = new WorkingSet(150, 5);
-    ws.recordSelection("alpha", 0, true);
-
-    ws.evict(100, new Set());
-
-    expect(ws.union().has("alpha")).toBe(true);
-  });
-
-  test("exceeding maxPages evicts the least-recently-selected non-pinned page first", () => {
-    const ws = new WorkingSet(2, 1000);
-    ws.recordSelection("oldest", 1, false);
-    ws.recordSelection("middle", 2, false);
-    ws.recordSelection("newest", 3, false);
-
-    // No window eviction (window huge); cap is 2 → drop lowest lastSeenTurn.
-    ws.evict(3, new Set());
-
-    expect(ws.size()).toBe(2);
-    expect(ws.union().has("oldest")).toBe(false);
-    expect(ws.union().has("middle")).toBe(true);
-    expect(ws.union().has("newest")).toBe(true);
-  });
-
-  test("cap eviction never drops pinned pages even when over capacity", () => {
-    const ws = new WorkingSet(1, 1000);
-    ws.recordSelection("pinned-a", 1, true);
-    ws.recordSelection("pinned-b", 2, true);
-    ws.recordSelection("loose", 3, false);
-
-    ws.evict(3, new Set());
-
-    // Only the non-pinned page can go; pinned pages stay even over cap.
-    expect(ws.union().has("pinned-a")).toBe(true);
-    expect(ws.union().has("pinned-b")).toBe(true);
-    expect(ws.union().has("loose")).toBe(false);
-    expect(ws.size()).toBe(2);
-  });
-
-  test("core slugs passed to evict are dropped if present", () => {
-    const ws = new WorkingSet(150, 5);
-    ws.recordSelection("alpha", 5, false);
-    ws.recordSelection("beta", 5, true); // pinned, but core still wins
-    ws.recordSelection("gamma", 5, false);
-
-    ws.evict(5, new Set(["alpha", "beta"]));
-
-    expect(ws.union().has("alpha")).toBe(false);
-    expect(ws.union().has("beta")).toBe(false);
-    expect(ws.union().has("gamma")).toBe(true);
-  });
-
-  test("custom scoreFn reorders cap-evictions", () => {
-    // Score by selectedAtTurn instead of lastSeenTurn: the page selected
-    // earliest becomes most evictable regardless of recent activity.
-    const bySelectedAt: ScoreFn = (e: WorkingSetEntry) => e.selectedAtTurn;
-    const ws = new WorkingSet(2, 1000, bySelectedAt);
-
-    ws.recordSelection("first", 0, false);
-    ws.recordSelection("second", 1, false);
-    ws.recordSelection("third", 2, false);
-    // Bump "first" so plain LRU would protect it, but selectedAt still lowest.
-    ws.recordSelection("first", 9, false);
-
-    ws.evict(9, new Set());
-
-    expect(ws.size()).toBe(2);
-    // Under custom score, "first" (selectedAt 0) evicts despite recent touch.
-    expect(ws.union().has("first")).toBe(false);
-    expect(ws.union().has("second")).toBe(true);
-    expect(ws.union().has("third")).toBe(true);
-  });
-
-  test("default no-arg constructor still works for existing callers", () => {
-    const ws = new WorkingSet();
-    ws.recordSelection("alpha", 0, false);
-    expect(ws.size()).toBe(1);
-  });
-});

package/src/plugins/defaults/memory-v3-shadow/__tests__/working-set-skeleton.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { WorkingSet } from "../working-set.js";
-
-describe("WorkingSet (skeleton)", () => {
-  test("recording a selection adds it to union()", () => {
-    const ws = new WorkingSet();
-    ws.recordSelection("alpha", 1, false);
-
-    expect(ws.union().has("alpha")).toBe(true);
-    expect(ws.size()).toBe(1);
-  });
-
-  test("recording the same slug twice preserves selectedAtTurn and updates lastSeenTurn", () => {
-    const ws = new WorkingSet();
-    ws.recordSelection("alpha", 1, false);
-    ws.recordSelection("alpha", 5, false);
-
-    expect(ws.size()).toBe(1);
-    const entry = [...ws.union()];
-    expect(entry).toEqual(["alpha"]);
-    // selectedAtTurn preserved at original turn, lastSeenTurn advanced.
-    const internal = (
-      ws as unknown as {
-        entries: Map<string, { selectedAtTurn: number; lastSeenTurn: number }>;
-      }
-    ).entries.get("alpha");
-    expect(internal?.selectedAtTurn).toBe(1);
-    expect(internal?.lastSeenTurn).toBe(5);
-  });
-
-  test("pinned propagates: non-pinned then pinned keeps pinned true", () => {
-    const ws = new WorkingSet();
-    ws.recordSelection("alpha", 1, false);
-    ws.recordSelection("alpha", 2, true);
-
-    const internal = (
-      ws as unknown as {
-        entries: Map<string, { pinned: boolean }>;
-      }
-    ).entries.get("alpha");
-    expect(internal?.pinned).toBe(true);
-  });
-});

package/src/plugins/defaults/memory-v3-shadow/working-set.ts

@@ -1,91 +0,0 @@
-import { Slug, WorkingSetEntry } from "./types.js";
-
-/**
- * Scores a working-set entry for cap eviction. Lower score = more evictable.
- * This is the pluggable seam for a future salience-weighted policy; the
- * default is plain LRU on `lastSeenTurn`.
- */
-export type ScoreFn = (entry: WorkingSetEntry) => number;
-
-/** Default eviction score: least-recently-seen entries evict first. */
-function lruScore(entry: WorkingSetEntry): number {
-  return entry.lastSeenTurn;
-}
-
-export class WorkingSet {
-  private entries = new Map<Slug, WorkingSetEntry>();
-
-  constructor(
-    private readonly maxPages = 150,
-    private readonly evictWindow = 5,
-    private readonly scoreFn: ScoreFn = lruScore,
-  ) {}
-
-  recordSelection(slug: Slug, turn: number, pinned: boolean): void {
-    const existing = this.entries.get(slug);
-    this.entries.set(slug, {
-      slug,
-      selectedAtTurn: existing?.selectedAtTurn ?? turn,
-      pinned: existing?.pinned || pinned,
-      lastSeenTurn: turn,
-    });
-  }
-
-  union(): Set<Slug> {
-    return new Set(this.entries.keys());
-  }
-
-  size(): number {
-    return this.entries.size;
-  }
-
-  /**
-   * Prune the working set, in order:
-   *   1. Core slugs never belong here — drop any entry whose slug is core.
-   *      The section-lane pipeline has no core set, so `coreSlugs` defaults to
-   *      empty (no-op); the tree pipeline passed its core slugs here. Stale and
-   *      cap eviction semantics are identical either way.
-   *   2. Pinned entries never evict.
-   *   3. Window eviction: drop a non-pinned entry unseen for more than
-   *      `evictWindow` turns.
-   *   4. Cap eviction: while over `maxPages`, evict the lowest-scoring
-   *      non-pinned entry first (ties broken deterministically).
-   */
-  evict(currentTurn: number, coreSlugs: Set<Slug> = new Set()): void {
-    // 1. Core slugs are owned by core, not the working set.
-    for (const slug of this.entries.keys()) {
-      if (coreSlugs.has(slug)) {
-        this.entries.delete(slug);
-      }
-    }
-
-    // 2 + 3. Window eviction for stale non-pinned entries.
-    for (const [slug, entry] of this.entries) {
-      if (
-        !entry.pinned &&
-        currentTurn - entry.lastSeenTurn > this.evictWindow
-      ) {
-        this.entries.delete(slug);
-      }
-    }
-
-    // 4. Cap eviction: evict the lowest-scoring non-pinned entry until the
-    // set fits. Sort once (ascending score, then slug for determinism) and
-    // walk the candidates.
-    if (this.entries.size <= this.maxPages) {
-      return;
-    }
-    const evictable = [...this.entries.values()]
-      .filter((entry) => !entry.pinned)
-      .sort(
-        (a, b) =>
-          this.scoreFn(a) - this.scoreFn(b) || (a.slug < b.slug ? -1 : 1),
-      );
-    for (const entry of evictable) {
-      if (this.entries.size <= this.maxPages) {
-        break;
-      }
-      this.entries.delete(entry.slug);
-    }
-  }
-}

package/src/plugins/external-api.ts

@@ -1,114 +0,0 @@
-/**
- * External plugin runtime — `globalThis.__vellumPluginRuntime` bridge.
- *
- * ⚠️ DO NOT DELETE THIS AS "UNUSED". There is intentionally NO in-repo consumer:
- * the consumers are out-of-repo, user-authored workspace plugins under
- * `<workspaceDir>/plugins/*`, which a repo-wide reference search cannot see. On
- * a `bun --compile` daemon (the shipped macOS app) this bridge is the ONLY way
- * such a plugin can reach the daemon's real `assistantEventHub` /
- * `getSecureKeyAsync` singletons — an absolute-path `import` re-loads a disjoint
- * copy (see the module-identity note below). Removing it silently breaks every
- * event-subscribing workspace plugin on the next app rebuild. This was already
- * removed once on the false "unused" assumption (PR #33825) and restored here.
- *
- * Workspace-local plugins (`<workspaceDir>/plugins/*`) get dynamic-imported by
- * {@link loadUserPlugins}. They need to call `registerPlugin()` from their
- * module body and they typically also want to read secrets, subscribe to
- * runtime events, etc.
- *
- * Importing those symbols by absolute path
- * (`/abs/path/to/assistant/src/plugins/registry.js`) works when the daemon is
- * running from source — both the daemon and the dynamic-imported plugin
- * resolve the same on-disk file and share module identity. It DOES NOT work
- * when the daemon is a `bun --compile` binary: the daemon's modules are baked
- * into the executable, and any absolute-path import re-loads a fresh disk
- * copy. `registerPlugin()` then writes into a disjoint registry instance and
- * the daemon never sees the plugin.
- *
- * The fix is to expose a single, stable handle on `globalThis` that plugins
- * read at module-load time. The daemon's bundled modules attach themselves
- * here once at startup; plugins consume the same instance regardless of how
- * the daemon was built.
- *
- * Plugins use the bridge like this:
- *
- *   const runtime = (globalThis as { __vellumPluginRuntime?: ... })
- *     .__vellumPluginRuntime;
- *   if (!runtime || runtime.version !== 1) throw new Error("...");
- *   const { registerPlugin, assistantEventHub, getSecureKeyAsync } = runtime;
- *
- * Type-only imports (`import type { Plugin } from "..."`) remain free to use
- * absolute paths or workspace-local copies — the TypeScript compiler erases
- * them and they have no module-identity effect at runtime.
- *
- * See `experimental/plugins/README.md` for the full authoring contract and
- * `assistant/examples/plugins/echo/` for a worked example.
- */
-
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
-import { registerPlugin } from "./registry.js";
-
-/**
- * The handle plugins read from `globalThis.__vellumPluginRuntime`.
- *
- * `version` is the contract version. Plugins should assert against the
- * version they were authored against and refuse to register if they see a
- * different one — bumping it is a breaking change to the plugin surface.
- *
- * The field set is intentionally small: the most-commonly-needed symbols
- * across both static (module-load-time) and dynamic (init-time) plugin
- * lifecycle. Plugins that need richer runtime state can still receive it
- * through {@link PluginInitContext} during `init()`.
- */
-export interface VellumPluginRuntime {
-  readonly version: 1;
-  readonly registerPlugin: typeof registerPlugin;
-  readonly assistantEventHub: typeof assistantEventHub;
-  readonly getSecureKeyAsync: typeof getSecureKeyAsync;
-}
-
-/** Stable globalThis key. Don't rename — plugins reference it by string. */
-const RUNTIME_GLOBAL_KEY = "__vellumPluginRuntime" as const;
-
-interface GlobalWithRuntime {
-  [RUNTIME_GLOBAL_KEY]?: VellumPluginRuntime;
-}
-
-/**
- * Install the plugin runtime bridge on `globalThis`. Idempotent — repeat
- * calls are no-ops, so it's safe to invoke from tests that also touch the
- * lifecycle path.
- *
- * Must be called BEFORE {@link loadUserPlugins} runs, otherwise plugins that
- * touch `globalThis.__vellumPluginRuntime` in their module body will throw.
- */
-export function installPluginRuntime(): void {
-  const g = globalThis as GlobalWithRuntime;
-  if (g[RUNTIME_GLOBAL_KEY]) return;
-  g[RUNTIME_GLOBAL_KEY] = {
-    version: 1,
-    registerPlugin,
-    assistantEventHub,
-    getSecureKeyAsync,
-  };
-}
-
-/**
- * Read the installed runtime. Returns `undefined` if {@link installPluginRuntime}
- * hasn't been called yet — plugins should treat this as a fatal error.
- *
- * Exposed mainly for tests and for the rare in-process consumer that wants
- * to read the bridge from the same module graph that installed it.
- */
-export function getPluginRuntime(): VellumPluginRuntime | undefined {
-  return (globalThis as GlobalWithRuntime)[RUNTIME_GLOBAL_KEY];
-}
-
-/**
- * Tear down the runtime handle. Test-only — production code never uninstalls
- * because the runtime lifetime is the daemon lifetime.
- */
-export function uninstallPluginRuntimeForTests(): void {
-  delete (globalThis as GlobalWithRuntime)[RUNTIME_GLOBAL_KEY];
-}