@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/workspace-migration-082-backfill-managed-profile-labels.test.ts

@@ -0,0 +1,268 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { backfillManagedProfileLabelsMigration } from "../workspace/migrations/082-backfill-managed-profile-labels.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-082-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("082-backfill-managed-profile-labels migration", () => {
+  test("has correct migration id", () => {
+    expect(backfillManagedProfileLabelsMigration.id).toBe(
+      "082-backfill-managed-profile-labels",
+    );
+  });
+
+  test("backfills missing labels on the canonical managed triplet (Marina QA #5)", () => {
+    // The exact shape migration 052 writes — provider + model + numeric
+    // tuning fields, no label, no source, no provider_connection.
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            maxTokens: 16000,
+            effort: "high",
+            thinking: { enabled: true, streamThinking: true },
+          },
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            maxTokens: 32000,
+            effort: "max",
+            thinking: { enabled: true, streamThinking: true },
+          },
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+            maxTokens: 8192,
+            effort: "low",
+            thinking: { enabled: false, streamThinking: false },
+          },
+        },
+        activeProfile: "balanced",
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const profiles = (config.llm as Record<string, unknown>).profiles as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(profiles.balanced.label).toBe("Balanced");
+    expect(profiles["quality-optimized"].label).toBe("Quality");
+    expect(profiles["cost-optimized"].label).toBe("Speed");
+  });
+
+  test("preserves user-set string labels without rewriting", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            label: "My Balanced",
+          },
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            // No label — backfills.
+          },
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+            label: "Speed (Managed)",
+          },
+        },
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const profiles = (config.llm as Record<string, unknown>).profiles as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(profiles.balanced.label).toBe("My Balanced");
+    expect(profiles["quality-optimized"].label).toBe("Quality");
+    expect(profiles["cost-optimized"].label).toBe("Speed (Managed)");
+  });
+
+  test("preserves explicit null labels (user cleared the label)", () => {
+    // `null` is a meaningful signal — the user cleared the label via the
+    // PUT route. Treat the key as present and skip backfill.
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            label: null,
+          },
+        },
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const profiles = (config.llm as Record<string, unknown>).profiles as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(profiles.balanced.label).toBeNull();
+  });
+
+  test("does NOT touch non-canonical profile names", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "my-custom": {
+            provider: "openai",
+            model: "gpt-5.4",
+            // No label — must NOT be backfilled.
+          },
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+            // Missing label — gets backfilled.
+          },
+        },
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const profiles = (config.llm as Record<string, unknown>).profiles as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect("label" in profiles["my-custom"]).toBe(false);
+    expect(profiles.balanced.label).toBe("Balanced");
+  });
+
+  test("is idempotent — second run produces no further changes", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+          },
+        },
+      },
+    });
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+    const afterFirst = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+    const afterSecond = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("no-op when config.json does not exist", () => {
+    // Fresh workspace, no config file. Migration must not throw or create
+    // the file.
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("no-op when llm.profiles is absent", () => {
+    writeConfig({ llm: { default: { provider: "anthropic" } } });
+    const before = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+
+    backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+    const after = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+    expect(after).toBe(before);
+  });
+
+  test("ignores malformed config.json without throwing", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "{ not valid json");
+    // Should not throw.
+    expect(() =>
+      backfillManagedProfileLabelsMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+
+  test("does NOT skip when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    // Unlike the seed migrations (040/046/052/054/...), this is a forward
+    // data repair that runs regardless. Platform-supplied overlay labels
+    // already win at the profile level (the on-disk entry has a `label`
+    // key, so this migration leaves it alone). Skipping the whole
+    // migration when the env var is set would leave migration-052 holes
+    // unhealed on platform-style hatches.
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+          },
+        },
+      },
+    });
+
+    try {
+      backfillManagedProfileLabelsMigration.run(workspaceDir);
+
+      const config = readConfig();
+      const profiles = (config.llm as Record<string, unknown>)
+        .profiles as Record<string, Record<string, unknown>>;
+      expect(profiles.balanced.label).toBe("Balanced");
+    } finally {
+      delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+    }
+  });
+});

package/src/__tests__/workspace-migration-safe-storage-limits-release.test.ts

@@ -12,7 +12,6 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { releaseNotesSafeStorageLimitsMigration } from "../workspace/migrations/067-release-notes-safe-storage-limits.js";
 
 const MIGRATION_ID = "067-release-notes-safe-storage-limits";
-const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
 
 let workspaceDir: string;
 
@@ -28,10 +27,6 @@ function updatesPath(): string {
   return join(workspaceDir, "UPDATES.md");
 }
 
-function markerCount(content: string): number {
-  return content.split(MARKER).length - 1;
-}
-
 beforeEach(() => {
   freshWorkspace();
 });
@@ -47,44 +42,37 @@ describe("workspace migration 067-release-notes-safe-storage-limits", () => {
     expect(releaseNotesSafeStorageLimitsMigration.id).toBe(MIGRATION_ID);
   });
 
-  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+  test("does not create UPDATES.md when file is absent", () => {
     expect(existsSync(updatesPath())).toBe(false);
 
     releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
 
-    const content = readFileSync(updatesPath(), "utf-8");
-    expect(content).toContain(MARKER);
-    expect(content).toContain("safe-storage-limits");
-    expect(content).toContain("critical 95% threshold");
-    expect(content).toContain("trusted-contact messages");
+    expect(existsSync(updatesPath())).toBe(false);
   });
 
-  test("is idempotent when run twice", () => {
-    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+  test("leaves existing UPDATES.md byte-identical", () => {
+    const existing = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), existing, "utf-8");
+
     releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
 
-    const content = readFileSync(updatesPath(), "utf-8");
-    expect(markerCount(content)).toBe(1);
-    expect(content.match(/Safe storage limits/g)?.length).toBe(1);
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(existing);
   });
 
-  test("appends to existing UPDATES.md when marker is absent", () => {
-    const prior = "## Prior\n\nExisting release note.\n";
-    writeFileSync(updatesPath(), prior, "utf-8");
-
+  test("is idempotent when run twice in an empty workspace", () => {
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
     releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
 
-    const content = readFileSync(updatesPath(), "utf-8");
-    expect(content.startsWith(prior)).toBe(true);
-    expect(content).toContain(MARKER);
+    expect(existsSync(updatesPath())).toBe(false);
   });
 
-  test("is a no-op when marker is already present", () => {
-    const seeded = `## Prior\n\n${MARKER}\nAlready announced.\n`;
-    writeFileSync(updatesPath(), seeded, "utf-8");
+  test("is idempotent when run twice with existing UPDATES.md", () => {
+    const existing = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), existing, "utf-8");
 
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
     releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
 
-    expect(readFileSync(updatesPath(), "utf-8")).toBe(seeded);
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(existing);
   });
 });

package/src/__tests__/workspace-migration-unify-llm-callsite-configs.test.ts

@@ -127,9 +127,9 @@ describe("038-unify-llm-callsite-configs migration", () => {
     // if llm.default exists`) then silently skipped, and migration 039
     // stripped `services.inference.{provider,model}` — losing the user's
     // actual configuration. The fix prefers legacy source keys over the
-    // injected schema defaults whenever both are present. (The loader
-    // no longer writes defaults to disk, but workspaces still on disk
-    // from that era can carry the bad state forward.)
+    // injected schema defaults whenever both are present. (Defaults are
+    // applied in-memory only; legacy workspaces may still carry the
+    // on-disk state from that era.)
     writeConfig({
       services: {
         inference: {

package/src/__tests__/workspace-release-notes-feature-flag-guard.test.ts

@@ -0,0 +1,115 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+type Registry = {
+  flags: Array<{
+    key: string;
+    scope: string;
+    defaultEnabled: boolean;
+  }>;
+};
+
+const LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST = new Map<string, string>([
+  [
+    "045-release-notes-meet-avatar.ts",
+    "Historical bulletin that already shipped before this guard existed.",
+  ],
+]);
+
+const FLAGGED_FEATURE_LANGUAGE_PATTERNS: Array<{
+  label: string;
+  pattern: RegExp;
+}> = [
+  { label: "feature flag", pattern: /\bfeature[- ]flag(?:ged)?\b/i },
+  { label: "rollout flag", pattern: /\brollout flag\b/i },
+  { label: "behind ... flag", pattern: /\bbehind\b[^\n.]{0,120}\bflag\b/i },
+  { label: "gated on", pattern: /\bgated on\b/i },
+  { label: "when enabled", pattern: /\bwhen enabled\b/i },
+];
+
+function getRepoRoot(): string {
+  return join(process.cwd(), "..");
+}
+
+function getReleaseNoteMigrationFiles(): string[] {
+  const migrationsDir = join(process.cwd(), "src", "workspace", "migrations");
+  return readdirSync(migrationsDir)
+    .filter((fileName) => /^\d+-release-notes-[a-z0-9-]+\.ts$/.test(fileName))
+    .sort();
+}
+
+function loadDefaultDisabledAssistantFlagKeys(): string[] {
+  const registryPath = join(
+    getRepoRoot(),
+    "meta",
+    "feature-flags",
+    "feature-flag-registry.json",
+  );
+  const registry = JSON.parse(readFileSync(registryPath, "utf-8")) as Registry;
+  return registry.flags
+    .filter((flag) => flag.scope === "assistant" && !flag.defaultEnabled)
+    .map((flag) => flag.key)
+    .sort();
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function featureFlagKeyPattern(key: string): RegExp {
+  const escaped = escapeRegExp(key);
+  if (key.includes("-")) {
+    return new RegExp(`(?:^|[^a-z0-9-])${escaped}(?:$|[^a-z0-9-])`, "i");
+  }
+
+  return new RegExp("[`'\"]" + escaped + "[`'\"]", "i");
+}
+
+describe("workspace release-note migrations feature flag guard", () => {
+  test("new release-note migrations do not announce default-disabled feature-flagged work", () => {
+    const migrationsDir = join(process.cwd(), "src", "workspace", "migrations");
+    const defaultDisabledFlagKeys = loadDefaultDisabledAssistantFlagKeys();
+    const violations: string[] = [];
+
+    for (const fileName of getReleaseNoteMigrationFiles()) {
+      if (LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST.has(fileName)) {
+        continue;
+      }
+
+      const content = readFileSync(join(migrationsDir, fileName), "utf-8");
+
+      for (const { label, pattern } of FLAGGED_FEATURE_LANGUAGE_PATTERNS) {
+        if (pattern.test(content)) {
+          violations.push(
+            `${fileName}: contains flagged-feature language "${label}"`,
+          );
+        }
+      }
+
+      for (const key of defaultDisabledFlagKeys) {
+        if (featureFlagKeyPattern(key).test(content)) {
+          violations.push(
+            `${fileName}: references default-disabled assistant feature flag "${key}"`,
+          );
+        }
+      }
+    }
+
+    if (violations.length > 0) {
+      const message = [
+        "Release-note migrations write to UPDATES.md, which is processed without checking feature flags.",
+        "Do not announce features that are still behind default-disabled assistant flags or rollout flags.",
+        "Wait until GA and add a new append-only release-note migration with a new marker.",
+        "",
+        "Violations:",
+        ...violations.map((violation) => `  - ${violation}`),
+        "",
+        "If this is an already-shipped historical bulletin, add a narrow entry to",
+        "LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST in workspace-release-notes-feature-flag-guard.test.ts.",
+      ].join("\n");
+
+      expect(violations, message).toEqual([]);
+    }
+  });
+});

package/src/acp/__tests__/helpers/which-stub.ts

@@ -11,7 +11,8 @@
  * in `afterAll` so the swap doesn't leak into other files.
  */
 
-type WhichStub = (command: string) => string | null;
+type WhichOptions = { PATH?: string; cwd?: string };
+type WhichStub = (command: string, options?: WhichOptions) => string | null;
 
 /**
  * Installs a process-global stub for Bun.which. Returns helpers to drive and
@@ -30,7 +31,8 @@ export function installWhichStub(): {
   const originalWhich = Bun.which;
   let whichStub: WhichStub = () => null;
 
-  (Bun as unknown as { which: WhichStub }).which = (cmd) => whichStub(cmd);
+  (Bun as unknown as { which: WhichStub }).which = (cmd, options) =>
+    whichStub(cmd, options);
 
   function setWhich(arg: Record<string, string | null> | WhichStub): void {
     whichStub = typeof arg === "function" ? arg : (cmd) => arg[cmd] ?? null;

package/src/acp/resolve-agent.test.ts

@@ -161,6 +161,31 @@ describe("resolveAcpAgent", () => {
     expect(result.hint).toBe("npm i -g @zed-industries/codex-acp");
   });
 
+  test("binary preflight honors agent.env.PATH override (matches spawn env)", () => {
+    // The actual spawn merges `agentConfig.env` into the child env, so a
+    // per-agent PATH override wins over the daemon's PATH. The preflight
+    // must use the same PATH or it will reject configs that would have
+    // spawned successfully.
+    config.setConfig({
+      agents: {
+        custom: {
+          command: "my-binary",
+          args: [],
+          env: { PATH: "/opt/custom/bin" },
+        },
+      },
+    });
+    which.setWhich((cmd, options) =>
+      cmd === "my-binary" && options?.PATH === "/opt/custom/bin"
+        ? "/opt/custom/bin/my-binary"
+        : null,
+    );
+
+    const result = resolveAcpAgent("custom");
+
+    expect(result.ok).toBe(true);
+  });
+
   test("ok result when user config provides agent and binary is on PATH", () => {
     config.setConfig({
       agents: {

package/src/acp/resolve-agent.ts

@@ -65,6 +65,17 @@ function installHintFor(command: string): string {
     : `Install '${command}' and ensure it is on PATH.`;
 }
 
+/**
+ * Resolve the binary using the same PATH the spawn will see. `AcpAgentProcess`
+ * spawns with `{ ...process.env, ...config.env }`, so a per-agent `env.PATH`
+ * override wins over the daemon's PATH. Mirror that here so a config that
+ * relies on a custom PATH to locate the binary doesn't fail preflight.
+ */
+function findAgentBinary(agent: AcpAgentConfig): string | null {
+  const PATH = agent.env?.PATH ?? process.env.PATH;
+  return Bun.which(agent.command, PATH ? { PATH } : undefined);
+}
+
 /**
  * Resolve an id against user config first, then bundled defaults. Returns the
  * resolved entry plus a `source` label so callers can surface "user override
@@ -122,7 +133,7 @@ export function resolveAcpAgent(id: string): ResolveAcpAgentResult {
   }
 
   const { agent } = found;
-  if (!Bun.which(agent.command)) {
+  if (!findAgentBinary(agent)) {
     return {
       ok: false,
       reason: "binary_not_found",
@@ -157,7 +168,7 @@ export function listAcpAgents(): {
   const agents: AcpAgentEntry[] = mergedAgentIds(userAgents).map((id) => {
     // Non-null: ids come from `mergedAgentIds` so the lookup always resolves.
     const { agent, source } = lookupAgent(userAgents, id)!;
-    const available = Bun.which(agent.command) !== null;
+    const available = findAgentBinary(agent) !== null;
     const entry: AcpAgentEntry = {
       id,
       command: agent.command,

package/src/acp/session-manager.ts

@@ -278,12 +278,26 @@ export class AcpSessionManager {
 
   /**
    * Kills the agent process and removes the session from tracking.
+   *
+   * Persists the buffered event log first so abort paths
+   * (`executeAcpAbort`, daemon shutdown) don't drop history. If the
+   * session is still in a non-terminal state, mark it cancelled so the
+   * persisted row reflects reality. The in-flight prompt's then/catch
+   * handler will short-circuit after teardown removes the entry.
    */
   close(acpSessionId: string): void {
     const entry = this.sessions.get(acpSessionId);
     if (!entry) {
       throw new Error(`ACP session "${acpSessionId}" not found`);
     }
+    if (
+      entry.state.status === "running" ||
+      entry.state.status === "initializing"
+    ) {
+      entry.state.status = "cancelled";
+      entry.state.completedAt = Date.now();
+    }
+    this.persistTerminal(acpSessionId, entry);
     this.teardownSession(acpSessionId, entry);
   }
 

package/src/agent/loop.ts

@@ -96,6 +96,11 @@ export type AgentEvent =
       matchedTrustRuleId?: string;
       isContainerized?: boolean;
       riskScopeOptions?: Array<{ pattern: string; label: string }>;
+      riskAllowlistOptions?: Array<{
+        label: string;
+        description: string;
+        pattern: string;
+      }>;
       riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
       approvalMode?: string;
       approvalReason?: string;
@@ -282,6 +287,11 @@ export type LoopToolExecutor = (
   matchedTrustRuleId?: string;
   isContainerized?: boolean;
   riskScopeOptions?: Array<{ pattern: string; label: string }>;
+  riskAllowlistOptions?: Array<{
+    label: string;
+    description: string;
+    pattern: string;
+  }>;
   riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
   approvalMode?: string;
   approvalReason?: string;
@@ -1001,6 +1011,7 @@ export class AgentLoop {
             matchedTrustRuleId: result.matchedTrustRuleId,
             isContainerized: result.isContainerized,
             riskScopeOptions: result.riskScopeOptions,
+            riskAllowlistOptions: result.riskAllowlistOptions,
             riskDirectoryScopeOptions: result.riskDirectoryScopeOptions,
             approvalMode: result.approvalMode,
             approvalReason: result.approvalReason,

package/src/approvals/guardian-decision-primitive.ts

@@ -355,12 +355,6 @@ export type CanonicalDecisionResult =
       resolverFailed?: boolean;
       resolverFailureReason?: string;
       resolverReplyText?: string;
-      activatedContact?: {
-        sourceChannel: string;
-        externalUserId: string;
-        externalChatId?: string;
-        displayName?: string;
-      };
     }
   | {
       applied: false;
@@ -527,9 +521,6 @@ export async function applyCanonicalGuardianDecision(
   let resolverFailed = false;
   let resolverFailureReason: string | undefined;
   let resolverReplyText: string | undefined;
-  let activatedContact:
-    | { sourceChannel: string; externalUserId: string; externalChatId?: string; displayName?: string }
-    | undefined;
   const resolver = getResolver(request.kind);
   if (resolver) {
     const resolverResult = await resolver.resolve({
@@ -558,9 +549,6 @@ export async function applyCanonicalGuardianDecision(
       resolverFailureReason = resolverResult.reason;
     } else {
       resolverReplyText = resolverResult.guardianReplyText;
-      if (resolverResult.activatedContact) {
-        activatedContact = resolverResult.activatedContact;
-      }
     }
   } else {
     log.info(
@@ -612,6 +600,5 @@ export async function applyCanonicalGuardianDecision(
     grantMinted,
     ...(resolverFailed ? { resolverFailed, resolverFailureReason } : {}),
     ...(resolverReplyText ? { resolverReplyText } : {}),
-    ...(activatedContact ? { activatedContact } : {}),
   };
 }