@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/scripts/test.ts

@@ -0,0 +1,597 @@
+#!/usr/bin/env bun
+/**
+ * Test runner with full process isolation for Bun mock.module conflicts.
+ *
+ * Bun's mock.module is process-global: the last mock.module call for a given
+ * specifier wins across ALL test files in the process. Test files that mock a
+ * module would otherwise break test files that need the real implementation, so
+ * each test file runs in its own Bun process. Files run in parallel (configurable
+ * via TEST_WORKERS, default: CPU count).
+ *
+ * Coverage: set COVERAGE=true to generate per-file lcov reports, merged into
+ * coverage/lcov.info at the end.
+ *
+ * This is a TypeScript port of the former scripts/test.sh; behaviour is intended
+ * to match it exactly (file selection, longest-first scheduling, per-file
+ * timeout + retry, pass/hung/fail classification, coverage merge).
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+const EXCLUDE_EXPERIMENTAL = Bun.env.EXCLUDE_EXPERIMENTAL === "true";
+const WORKERS =
+  Number.parseInt(Bun.env.TEST_WORKERS ?? "", 10) ||
+  navigator.hardwareConcurrency ||
+  8;
+const COVERAGE = Bun.env.COVERAGE === "true";
+// Per-test timeout (seconds). Kills bun processes that pass but don't exit due
+// to open handles.
+const PER_TEST_TIMEOUT = Number.parseInt(Bun.env.PER_TEST_TIMEOUT ?? "120", 10);
+// SIGKILL grace after SIGTERM, mirroring `timeout -k 10`.
+const KILL_GRACE_MS = 10_000;
+// Longest-first scheduling: a durations file from a previous run sorts slow
+// tests to the front, improving parallel utilization.
+const TEST_DURATIONS_FILE = Bun.env.TEST_DURATIONS_FILE ?? "";
+const TEST_DURATIONS_OUTPUT = Bun.env.TEST_DURATIONS_OUTPUT ?? "";
+
+const EXPERIMENTAL_FILES = new Set([
+  "skill-load-tool.test.ts",
+  "memory-regressions.experimental.test.ts",
+]);
+
+// Tests that exist in the tree but are known-broken when run. Excluded
+// unconditionally until triage lands a fix for each. Entries must be
+// repo-relative paths (matching by basename would silently exclude every copy
+// of ambiguous names like `connect.test.ts` that recur under multiple
+// `src/cli/commands/*/__tests__/` directories). To triage: run
+// `bun test <path>` and fix until green, then remove it here.
+const KNOWN_BROKEN_FILES = new Set<string>([]);
+
+// ---------------------------------------------------------------------------
+// Feature-flag registry sync
+// ---------------------------------------------------------------------------
+
+// Ensure the bundled feature-flag-registry.json exists before running tests.
+// The canonical copy lives at meta/feature-flags/feature-flag-registry.json and
+// is synced into assistant/src/ and gateway/src/. CI runs this as a dedicated
+// step; locally postinstall handles it — but when node_modules is symlinked
+// (e.g. worktrees) postinstall never fires, so the bundled copy can be missing
+// and feature-flag-registry-bundled.test.ts fails. Running the sync here is
+// idempotent and cheap (two file copies).
+function syncFeatureFlagRegistry(): void {
+  const syncScript = join(
+    "..",
+    "meta",
+    "feature-flags",
+    "sync-bundled-copies.ts",
+  );
+  if (!existsSync(syncScript)) {
+    return;
+  }
+  Bun.spawnSync(["bun", "run", "meta/feature-flags/sync-bundled-copies.ts"], {
+    cwd: join(process.cwd(), ".."),
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Test-file collection
+// ---------------------------------------------------------------------------
+
+function collectTestFiles(): string[] {
+  const glob = new Bun.Glob("src/**/*.test.ts");
+  const files: string[] = [];
+  for (const file of glob.scanSync(".")) {
+    const base = basename(file);
+    if (EXCLUDE_EXPERIMENTAL && EXPERIMENTAL_FILES.has(base)) {
+      continue;
+    }
+    // Always exclude benchmark files — run them with `bun run test:bench`.
+    if (base.endsWith(".benchmark.test.ts")) {
+      continue;
+    }
+    // Compare against the full repo-relative path — matching by basename would
+    // silently drop every copy of ambiguous filenames.
+    if (KNOWN_BROKEN_FILES.has(file)) {
+      continue;
+    }
+    files.push(file);
+  }
+  return files.sort();
+}
+
+// Sort tests longest-first using durations from a previous run, so slow tests
+// start immediately across all workers instead of piling up at the end and
+// becoming long poles.
+function sortLongestFirst(files: string[]): string[] {
+  if (!TEST_DURATIONS_FILE || !existsSync(TEST_DURATIONS_FILE)) {
+    return files;
+  }
+  const durMap = new Map<string, number>();
+  for (const line of readFileSync(TEST_DURATIONS_FILE, "utf-8").split("\n")) {
+    if (!line) {
+      continue;
+    }
+    const tab = line.indexOf("\t");
+    if (tab === -1) {
+      continue;
+    }
+    const ms = Number.parseInt(line.slice(0, tab), 10);
+    const path = line.slice(tab + 1);
+    if (path) {
+      durMap.set(path, ms);
+    }
+  }
+  const known: string[] = [];
+  const unknown: string[] = [];
+  for (const f of files) {
+    (durMap.has(f) ? known : unknown).push(f);
+  }
+  known.sort((a, b) => (durMap.get(b) ?? 0) - (durMap.get(a) ?? 0));
+  console.log(
+    `Sorted tests longest-first using ${TEST_DURATIONS_FILE} (${known.length} known, ${unknown.length} new)`,
+  );
+  return [...known, ...unknown];
+}
+
+// ---------------------------------------------------------------------------
+// Running a single test file
+// ---------------------------------------------------------------------------
+
+interface RunResult {
+  exitCode: number;
+  output: string;
+  timedOut: boolean;
+}
+
+const hasFailedAssertion = (out: string): boolean => /^\(fail\)/m.test(out);
+const reachedEndOfRun = (out: string): boolean =>
+  /^Ran \d+ tests? across/m.test(out);
+
+async function runBunTest(
+  file: string,
+  coverageArgs: string[],
+): Promise<RunResult> {
+  const args = ["test", ...coverageArgs];
+  if (EXCLUDE_EXPERIMENTAL) {
+    args.push("--test-name-pattern", "^(?!.*\\[experimental\\])");
+  }
+  args.push(file);
+
+  const proc = Bun.spawn(["bun", ...args], { stdout: "pipe", stderr: "pipe" });
+
+  let timedOut = false;
+  let killTimer: ReturnType<typeof setTimeout> | null = null;
+  let graceTimer: ReturnType<typeof setTimeout> | null = null;
+  killTimer = setTimeout(() => {
+    timedOut = true;
+    proc.kill("SIGTERM");
+    graceTimer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+        /* already exited */
+      }
+    }, KILL_GRACE_MS);
+  }, PER_TEST_TIMEOUT * 1000);
+
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exitCode = await proc.exited;
+  if (killTimer) {
+    clearTimeout(killTimer);
+  }
+  if (graceTimer) {
+    clearTimeout(graceTimer);
+  }
+
+  return { exitCode, output: stdout + stderr, timedOut };
+}
+
+type Outcome = "pass" | "fail" | "hung-pass";
+
+interface FileResult {
+  file: string;
+  outcome: Outcome;
+  elapsedMs: number;
+  output: string;
+}
+
+async function runOneFile(
+  file: string,
+  resultsDir: string,
+): Promise<FileResult> {
+  const base = basename(file);
+  const coverageArgs: string[] = [];
+  if (COVERAGE) {
+    const safe = file.replace(/\//g, "_");
+    const covDir = join(resultsDir, `cov_${safe}`);
+    mkdirSync(covDir, { recursive: true });
+    coverageArgs.push(
+      "--coverage",
+      "--coverage-reporter=lcov",
+      `--coverage-dir=${covDir}`,
+    );
+  }
+
+  const start = performance.now();
+  let { exitCode, output, timedOut } = await runBunTest(file, coverageArgs);
+
+  // Retry once when a failing run produced no conclusive test evidence:
+  //   - transient loader/runtime crash (non-zero, non-timeout exit)
+  //   - transient hang (timeout kill before the end-of-run summary)
+  // Neither leaves a "(fail)" line; genuine assertion failures print one and
+  // are reported immediately (fast feedback, no masking of intermittent
+  // failures). A timed-out run that reached the end-of-run summary is the
+  // passed-but-hung-at-exit case — no retry needed.
+  let retryReason = "";
+  if (exitCode !== 0 && !hasFailedAssertion(output)) {
+    if (timedOut) {
+      if (!reachedEndOfRun(output)) {
+        retryReason = `hung after ${PER_TEST_TIMEOUT}s without completing`;
+      }
+    } else {
+      retryReason = `transient crash, exit ${exitCode}`;
+    }
+  }
+  if (retryReason) {
+    console.log(`  ↻ ${base} (${retryReason} — retrying once)`);
+    ({ exitCode, output, timedOut } = await runBunTest(file, coverageArgs));
+  }
+
+  const elapsedMs = Math.round(performance.now() - start);
+
+  let outcome: Outcome;
+  let line: string;
+  if (timedOut) {
+    // The process was killed by the timeout. It passed only if there were no
+    // failures AND the end-of-run summary is present; without the summary it
+    // was killed mid-run.
+    if (hasFailedAssertion(output)) {
+      outcome = "fail";
+      line = `  ✗ ${base} (killed after ${PER_TEST_TIMEOUT}s — tests failed and process hung)`;
+    } else if (reachedEndOfRun(output)) {
+      outcome = "hung-pass";
+      line = `  ⚠ ${base} (tests passed but process hung after ${PER_TEST_TIMEOUT}s — likely open handles)`;
+    } else {
+      outcome = "fail";
+      line = `  ✗ ${base} (killed after ${PER_TEST_TIMEOUT}s — test run did not complete)`;
+    }
+  } else if (exitCode !== 0) {
+    outcome = "fail";
+    line = `  ✗ ${base} (${elapsedMs}ms)`;
+  } else {
+    outcome = "pass";
+    line = `  ✓ ${base} (${elapsedMs}ms)`;
+  }
+  console.log(line);
+
+  return { file, outcome, elapsedMs, output };
+}
+
+// ---------------------------------------------------------------------------
+// Concurrency pool
+// ---------------------------------------------------------------------------
+
+async function runPool<T, R>(
+  items: T[],
+  concurrency: number,
+  worker: (item: T) => Promise<R>,
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  let next = 0;
+  const runner = async (): Promise<void> => {
+    while (true) {
+      const idx = next++;
+      if (idx >= items.length) {
+        return;
+      }
+      results[idx] = await worker(items[idx]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, items.length) }, runner),
+  );
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Coverage merge (port of the former awk merge)
+//
+// Merges per-shard lcov reports, deduplicating source files that appear in
+// multiple shards — raw concatenation would count shared files multiple times.
+// DA/FNDA/BRDA execution counts are summed; FN/DA/BRDA identities keep their
+// first-seen order.
+// ---------------------------------------------------------------------------
+
+function mergeLcov(rawLcovDir: string, mergedPath: string): boolean {
+  interface FileCov {
+    daOrder: string[]; // line numbers in first-seen order
+    da: Map<string, number>; // line -> summed count
+    fnOrder: string[]; // "line,name" in first-seen order
+    fnSeen: Set<string>;
+    fndaOrder: string[]; // "line,name" in first-seen order
+    fnda: Map<string, number>; // "line,name" -> summed count
+    brdaOrder: string[]; // "line,block,branch" in first-seen order
+    brda: Map<string, number>; // key -> summed taken
+    brdaNumeric: Set<string>; // keys that had a numeric taken
+  }
+  const filesMap = new Map<string, FileCov>();
+  const fileOrder: string[] = [];
+
+  const emptyCov = (): FileCov => ({
+    daOrder: [],
+    da: new Map(),
+    fnOrder: [],
+    fnSeen: new Set(),
+    fndaOrder: [],
+    fnda: new Map(),
+    brdaOrder: [],
+    brda: new Map(),
+    brdaNumeric: new Set(),
+  });
+
+  // Concatenate all shard lcov files, then walk line by line.
+  const shardDirs = readdirSync(rawLcovDir).filter((d) => d.startsWith("cov_"));
+  let sawAny = false;
+  for (const dir of shardDirs) {
+    const lcovFile = join(rawLcovDir, dir, "lcov.info");
+    if (!existsSync(lcovFile)) {
+      continue;
+    }
+    sawAny = true;
+    let cur: FileCov | null = null;
+    // FN/FNDA are paired by position WITHIN a shard's SF block.
+    let blkFnAt: string[] = [];
+    let blkFndaIdx = 0;
+    for (const raw of readFileSync(lcovFile, "utf-8").split("\n")) {
+      if (raw.startsWith("SF:")) {
+        const sf = raw.slice(3);
+        if (!filesMap.has(sf)) {
+          filesMap.set(sf, emptyCov());
+          fileOrder.push(sf);
+        }
+        cur = filesMap.get(sf)!;
+        blkFnAt = [];
+        blkFndaIdx = 0;
+      } else if (raw.startsWith("DA:") && cur) {
+        const [line, countStr] = raw.slice(3).split(",");
+        const count = Number.parseInt(countStr, 10) || 0;
+        if (cur.da.has(line)) {
+          cur.da.set(line, cur.da.get(line)! + count);
+        } else {
+          cur.da.set(line, count);
+          cur.daOrder.push(line);
+        }
+      } else if (raw.startsWith("FN:") && cur) {
+        const entry = raw.slice(3); // "line,name"
+        if (!cur.fnSeen.has(entry)) {
+          cur.fnSeen.add(entry);
+          cur.fnOrder.push(entry);
+        }
+        blkFnAt.push(entry);
+      } else if (raw.startsWith("FNDA:") && cur) {
+        const rest = raw.slice(5); // "count,name"
+        const count = Number.parseInt(rest.split(",")[0], 10) || 0;
+        // Pair with the FN at the same position within this shard's block.
+        const fnFull = blkFnAt[blkFndaIdx] ?? rest.slice(rest.indexOf(",") + 1);
+        blkFndaIdx++;
+        if (cur.fnda.has(fnFull)) {
+          cur.fnda.set(fnFull, cur.fnda.get(fnFull)! + count);
+        } else {
+          cur.fnda.set(fnFull, count);
+          cur.fndaOrder.push(fnFull);
+        }
+      } else if (raw.startsWith("BRDA:") && cur) {
+        const parts = raw.slice(5).split(",");
+        const key = `${parts[0]},${parts[1]},${parts[2]}`;
+        const taken = parts[3];
+        if (taken === "-") {
+          if (!cur.brdaNumeric.has(key) && !cur.brda.has(key)) {
+            cur.brda.set(key, 0);
+          }
+        } else {
+          const t = Number.parseInt(taken, 10) || 0;
+          if (cur.brdaNumeric.has(key)) {
+            cur.brda.set(key, (cur.brda.get(key) ?? 0) + t);
+          } else {
+            cur.brda.set(key, t);
+          }
+          cur.brdaNumeric.add(key);
+        }
+        if (!cur.brdaOrder.includes(key)) {
+          cur.brdaOrder.push(key);
+        }
+      }
+    }
+  }
+
+  if (!sawAny) {
+    return false;
+  }
+
+  const out: string[] = [];
+  for (const sf of fileOrder) {
+    const cov = filesMap.get(sf)!;
+    out.push(`SF:${sf}`);
+    for (const fn of cov.fnOrder) {
+      out.push(`FN:${fn}`);
+    }
+    let fnf = 0;
+    let fnh = 0;
+    for (const entry of cov.fndaOrder) {
+      const count = cov.fnda.get(entry)!;
+      // entry is "line,name" — strip leading "line," to get the name.
+      const comma = entry.indexOf(",");
+      const name = comma === -1 ? entry : entry.slice(comma + 1);
+      out.push(`FNDA:${count},${name}`);
+      fnf++;
+      if (count > 0) {
+        fnh++;
+      }
+    }
+    out.push(`FNF:${fnf}`);
+    out.push(`FNH:${fnh}`);
+    let brf = 0;
+    let brh = 0;
+    const brLines: string[] = [];
+    for (const key of cov.brdaOrder) {
+      if (cov.brdaNumeric.has(key)) {
+        const taken = cov.brda.get(key)!;
+        brLines.push(`BRDA:${key},${taken}`);
+        brf++;
+        if (taken > 0) {
+          brh++;
+        }
+      } else {
+        brLines.push(`BRDA:${key},-`);
+        brf++;
+      }
+    }
+    out.push(...brLines);
+    if (brf > 0) {
+      out.push(`BRF:${brf}`);
+      out.push(`BRH:${brh}`);
+    }
+    let lf = 0;
+    let lh = 0;
+    for (const line of cov.daOrder) {
+      const count = cov.da.get(line)!;
+      out.push(`DA:${line},${count}`);
+      lf++;
+      if (count > 0) {
+        lh++;
+      }
+    }
+    out.push(`LF:${lf}`);
+    out.push(`LH:${lh}`);
+    out.push("end_of_record");
+  }
+  writeFileSync(mergedPath, out.join("\n") + "\n");
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Migrated-workspace fixture
+// ---------------------------------------------------------------------------
+
+// Build the migrated-DB fixture once, up front, in a dedicated subprocess. Each
+// test process's preload copies it into that process's tmp workspace, so a test
+// that calls initializeDb() opens an already-migrated DB and the migration
+// runner no-ops via its checkpoint ledger instead of re-running the whole chain
+// ~1800 times. The subprocess (rather than an in-process import) keeps the
+// persistence graph out of this orchestrator and mirrors a real from-scratch
+// migration. Workers are handed the fixtures root via VELLUM_TEST_FIXTURES_DIR
+// (inherited through Bun.spawn's default env inheritance); "migrated" is one
+// named fixture under it, leaving room for more.
+async function buildMigratedFixture(outWorkspaceDir: string): Promise<void> {
+  const script = join(import.meta.dir, "build-test-fixtures.ts");
+  const proc = Bun.spawn(["bun", "run", script, outWorkspaceDir], {
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  const code = await proc.exited;
+  if (code !== 0) {
+    console.error(`Failed to build migrated test fixture (exit ${code})`);
+    process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  syncFeatureFlagRegistry();
+
+  let testFiles = collectTestFiles();
+  if (testFiles.length === 0) {
+    console.log("No test files found under src");
+    process.exit(1);
+  }
+  testFiles = sortLongestFirst(testFiles);
+
+  const fixturesRoot = mkdtempSync(join(tmpdir(), "vellum-test-fixtures-"));
+  await buildMigratedFixture(join(fixturesRoot, "migrated"));
+  process.env.VELLUM_TEST_FIXTURES_DIR = fixturesRoot;
+
+  console.log(`Running ${testFiles.length} test files (${WORKERS} workers)`);
+
+  const resultsDir = mkdtempSync(join(tmpdir(), "vellum-test-run-"));
+  let coverageBase = "";
+  if (COVERAGE) {
+    coverageBase = join(process.cwd(), "coverage");
+    rmSync(coverageBase, { recursive: true, force: true });
+    mkdirSync(coverageBase, { recursive: true });
+  }
+
+  try {
+    const results = await runPool(testFiles, WORKERS, (f) =>
+      runOneFile(f, resultsDir),
+    );
+
+    // Record durations for longest-first scheduling in future runs. Written
+    // before the failure exit so durations persist even when tests fail.
+    if (TEST_DURATIONS_OUTPUT) {
+      const sorted = [...results].sort((a, b) => b.elapsedMs - a.elapsedMs);
+      writeFileSync(
+        TEST_DURATIONS_OUTPUT,
+        sorted.map((r) => `${r.elapsedMs}\t${r.file}`).join("\n") + "\n",
+      );
+      console.log(`Wrote test durations to ${TEST_DURATIONS_OUTPUT}`);
+    }
+
+    const failures = results.filter((r) => r.outcome === "fail");
+    if (failures.length > 0) {
+      console.log("");
+      for (const r of failures) {
+        console.log("──────────────────────────────────────────");
+        console.log(`FAIL: ${r.file}`);
+        console.log("──────────────────────────────────────────");
+        process.stdout.write(r.output);
+        console.log("");
+      }
+      console.log("========================================");
+      console.log(`  FAILED TEST FILES (${failures.length}):`);
+      console.log("========================================");
+      for (const r of failures) {
+        console.log(`  ✗ ${r.file}`);
+      }
+      console.log("========================================");
+      process.exit(1);
+    }
+
+    if (COVERAGE) {
+      const mergedPath = join(coverageBase, "lcov.info");
+      if (mergeLcov(resultsDir, mergedPath)) {
+        console.log("Coverage report written to coverage/lcov.info");
+      } else {
+        console.log("Warning: no coverage data was generated");
+      }
+    }
+
+    console.log(`All ${testFiles.length} test files passed`);
+  } finally {
+    rmSync(resultsDir, { recursive: true, force: true });
+    rmSync(fixturesRoot, { recursive: true, force: true });
+  }
+}
+
+await main();

package/src/__tests__/access-request-card-view.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   buildAccessRequestCardView,
+  buildAccessRequestContractText,
   parseAccessRequestPayload,
 } from "../notifications/access-request-copy.js";
 
@@ -96,3 +97,40 @@ describe("buildAccessRequestCardView", () => {
     expect(view({}).warnings).toEqual([]);
   });
 });
+
+describe("admitted-mode introduction nudge copy", () => {
+  test("view.admitted reflects the trigger marker", () => {
+    expect(view({ trigger: "admitted" }).admitted).toBe(true);
+    expect(view({}).admitted).toBe(false);
+    expect(view({ trigger: "denied" }).admitted).toBe(false);
+  });
+
+  test("contract identity line branches on the trigger", () => {
+    const base = {
+      actorDisplayName: "Alice",
+      senderIdentifier: "Alice",
+      sourceChannel: "telegram",
+    };
+    expect(buildAccessRequestContractText(base)).toContain(
+      "is requesting access to the assistant.",
+    );
+    const admitted = buildAccessRequestContractText({
+      ...base,
+      trigger: "admitted",
+    });
+    expect(admitted).toContain("messaged the assistant and was admitted");
+    expect(admitted).not.toContain("is requesting access");
+  });
+
+  test("admitted contract text keeps the decision directives", () => {
+    const text = buildAccessRequestContractText({
+      actorDisplayName: "Alice",
+      sourceChannel: "telegram",
+      requestCode: "ab12cd",
+      trigger: "admitted",
+    });
+    expect(text).toContain('"AB12CD trust"');
+    expect(text).toContain('"AB12CD reject"');
+    expect(text).toContain('"AB12CD block"');
+  });
+});

package/src/__tests__/activation-early-marking.test.ts

@@ -16,17 +16,10 @@
 
 import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 const { applyBootstrapTemplate } = await import("../prompts/system-prompt.js");
 const { isActivationSession } =
   await import("../plugins/defaults/memory/activation-session-store.js");