@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/workspace/migrations/152-repair-retired-fireworks-minimax-m2p7-model-id.ts

@@ -0,0 +1,198 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Repair the retired Fireworks MiniMax M2.7 model ID in workspace LLM
+ * config.
+ *
+ * Fireworks has no serverless deployment of
+ * `accounts/fireworks/models/minimax-m2p7`: the model page claims
+ * serverless support, but chat/completions calls fail with a 404 "Model
+ * not found, inaccessible, and/or not deployed". Existing configs can pin
+ * the ID in `llm.default`, `llm.callSites.*`, and `llm.profiles.*`.
+ *
+ * Repair those leaves only on an exact stale match, replacing with
+ * `accounts/fireworks/models/minimax-m3`: the only MiniMax model Fireworks
+ * serves serverless, at the same per-token pricing. Because m3 is also the
+ * balanced-intent template's model, a repaired hand-edited `custom-*`
+ * profile can read as unedited to `ensureByokDefaultProfiles` and collapse
+ * into the balanced default. That is acceptable: the collapsed copy routes
+ * to the same model this migration writes.
+ *
+ * Provider guard: the stale ID belongs to the `fireworks` provider and also
+ * appears in managed profiles stamped `provider: "vellum"` (which route
+ * Fireworks-account model IDs through the managed proxy). Under the entries
+ * model (migration 145) `provider` can also hold a `provider_connections`
+ * entry name whose row kind drives dispatch. A fragment is repaired when
+ * its `provider` is `"fireworks"`, `"vellum"`, absent, or an entry name
+ * whose row kind is one of those. Any other provider is left untouched: an
+ * `openai-compatible` endpoint may legitimately serve a model by the stale
+ * name.
+ */
+export const repairRetiredFireworksMinimaxM2p7ModelIdMigration: WorkspaceMigration =
+  {
+    id: "152-repair-retired-fireworks-minimax-m2p7-model-id",
+    description:
+      "Repair retired Fireworks accounts/fireworks/models/minimax-m2p7 model ID in workspace LLM config",
+    run(workspaceDir: string): void {
+      const configPath = join(workspaceDir, "config.json");
+      if (!existsSync(configPath)) {
+        return;
+      }
+
+      // Read outside the parse catch: a transient filesystem error (EIO,
+      // EACCES) must reach the runner so the migration retries, while
+      // malformed JSON is a permanent state this migration cannot repair.
+      const rawText = readFileSync(configPath, "utf-8");
+
+      let config: Record<string, unknown>;
+      try {
+        const raw = JSON.parse(rawText);
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+          return;
+        }
+        config = raw as Record<string, unknown>;
+      } catch {
+        return;
+      }
+
+      const llm = readObject(config.llm);
+      if (llm === null) {
+        return;
+      }
+
+      // Entry rows load lazily: only a stale fragment whose provider is
+      // neither a repairable vendor nor absent needs them. An unreadable DB
+      // then fails the run (retried next boot) rather than checkpointing a
+      // pass that skips entry-bound profiles.
+      let rows: Map<string, string> | null | undefined;
+      const isRepairableProvider = (provider: unknown): boolean => {
+        if (provider === undefined) {
+          return true;
+        }
+        if (typeof provider !== "string") {
+          return false;
+        }
+        if (REPAIRABLE_PROVIDERS.has(provider)) {
+          return true;
+        }
+        if (rows === undefined) {
+          rows = readConnectionRows(workspaceDir);
+        }
+        if (rows === null) {
+          throw new Error(
+            "provider_connections is not readable; retrying the model-ID repair on the next run",
+          );
+        }
+        const kind = rows.get(provider);
+        return kind !== undefined && REPAIRABLE_PROVIDERS.has(kind);
+      };
+
+      let changed = false;
+
+      changed =
+        repairFragment(readObject(llm.default), isRepairableProvider) ||
+        changed;
+
+      const callSites = readObject(llm.callSites);
+      if (callSites !== null) {
+        for (const rawConfig of Object.values(callSites)) {
+          changed =
+            repairFragment(readObject(rawConfig), isRepairableProvider) ||
+            changed;
+        }
+      }
+
+      const profiles = readObject(llm.profiles);
+      if (profiles !== null) {
+        for (const rawProfile of Object.values(profiles)) {
+          changed =
+            repairFragment(readObject(rawProfile), isRepairableProvider) ||
+            changed;
+        }
+      }
+
+      if (!changed) {
+        return;
+      }
+
+      // Write-then-rename so an interrupted write cannot leave config.json
+      // truncated: a torn in-place write would parse as invalid JSON on the
+      // retry, which the catch above treats as "nothing to do", letting the
+      // runner checkpoint the migration as completed against a corrupt file.
+      const tmpPath = `${configPath}.migration-152.tmp`;
+      writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n");
+      renameSync(tmpPath, configPath);
+    },
+    // The exact-match rewrite is idempotent, so a transient failure (full
+    // disk, I/O error) is safe to retry on later startups.
+    retryFailedCheckpoint: true,
+    down(_workspaceDir: string): void {
+      // Forward-only: reintroducing the retired model ID would break
+      // Fireworks calls.
+    },
+  };
+
+// ---------------------------------------------------------------------------
+// Helpers: self-contained per workspace migrations AGENTS.md
+// ---------------------------------------------------------------------------
+
+const STALE_MODEL_ID = "accounts/fireworks/models/minimax-m2p7";
+const REPLACEMENT_MODEL_ID = "accounts/fireworks/models/minimax-m3";
+const REPAIRABLE_PROVIDERS = new Set(["fireworks", "vellum"]);
+
+function repairFragment(
+  fragment: Record<string, unknown> | null,
+  isRepairableProvider: (provider: unknown) => boolean,
+): boolean {
+  if (fragment === null) {
+    return false;
+  }
+  if (fragment.model !== STALE_MODEL_ID) {
+    return false;
+  }
+  if (!isRepairableProvider(fragment.provider)) {
+    return false;
+  }
+  fragment.model = REPLACEMENT_MODEL_ID;
+  return true;
+}
+
+/**
+ * Connection name -> provider kind, or null when the DB or table is not
+ * readable. The caller fails the run on null: entry-name providers must be
+ * judged against real rows, never guessed. An absent DB file is a real
+ * state (no rows, so every entry name is dangling and stays untouched).
+ */
+function readConnectionRows(workspaceDir: string): Map<string, string> | null {
+  const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+  if (!existsSync(dbPath)) {
+    return new Map();
+  }
+  let db: Database;
+  try {
+    db = new Database(dbPath);
+  } catch {
+    return null;
+  }
+  try {
+    const rows = db
+      .query(`SELECT name, provider FROM provider_connections`)
+      .all() as Array<{ name: string; provider: string }>;
+    return new Map(rows.map((r) => [r.name, r.provider]));
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}

package/src/workspace/migrations/__tests__/150-stt-flux-provider-to-model-family.test.ts

@@ -4,7 +4,6 @@ import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import { sttFluxProviderToModelFamilyMigration } from "../150-stt-flux-provider-to-model-family.js";
-import { WORKSPACE_MIGRATIONS } from "../registry.js";
 
 function workspaceWith(config: unknown): string {
   const dir = mkdtempSync(join(tmpdir(), "stt-flux-migration-"));
@@ -17,15 +16,6 @@ function readConfig(dir: string): any {
 }
 
 describe("150-stt-flux-provider-to-model-family", () => {
-  test("is registered as the newest migration", () => {
-    expect(sttFluxProviderToModelFamilyMigration.id).toBe(
-      "150-stt-flux-provider-to-model-family",
-    );
-    expect(WORKSPACE_MIGRATIONS.at(-1)?.id).toBe(
-      "150-stt-flux-provider-to-model-family",
-    );
-  });
-
   test("rewrites a Flux provider id to its parent plus a model family", () => {
     const dir = workspaceWith({
       services: { stt: { provider: "deepgram-flux", providers: {} } },

package/src/workspace/migrations/registry.ts

@@ -148,6 +148,8 @@ import { renameCollidingBackupProfileNamesMigration } from "./147-rename-collidi
 import { stripUnsupportedFallbackProfilesMigration } from "./148-strip-unsupported-fallback-profiles.js";
 import { repointBackupProfileSelectionsMigration } from "./149-repoint-backup-profile-selections.js";
 import { sttFluxProviderToModelFamilyMigration } from "./150-stt-flux-provider-to-model-family.js";
+import { repairRenamedFireworksDeepseekProModelIdMigration } from "./151-repair-renamed-fireworks-deepseek-pro-model-id.js";
+import { repairRetiredFireworksMinimaxM2p7ModelIdMigration } from "./152-repair-retired-fireworks-minimax-m2p7-model-id.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -311,4 +313,6 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   stripUnsupportedFallbackProfilesMigration,
   repointBackupProfileSelectionsMigration,
   sttFluxProviderToModelFamilyMigration,
+  repairRenamedFireworksDeepseekProModelIdMigration,
+  repairRetiredFireworksMinimaxM2p7ModelIdMigration,
 ];

package/docker-kata-pip-chroot.sh

@@ -1,22 +0,0 @@
-#!/usr/bin/env sh
-# Runs pip inside the persistent apt chroot. Must be invoked under `unshare -m`
-# (see docker-kata-pip.sh): the bind mounts below live in a private mount
-# namespace so they disappear with the pip process and are never visible to
-# other processes — a lingering /data bind inside the chroot would create a
-# path cycle (/data/system/data/system/...) for anything walking /data.
-set -eu
-
-DATA_ROOT="$1"
-CALLER_CWD="$2"
-PIP_BIN="$3"
-shift 3
-
-for dir in /workspace /data /tmp /var/tmp; do
-  [ -d "${dir}" ] || continue
-  mkdir -p "${DATA_ROOT}${dir}"
-  mount --bind "${dir}" "${DATA_ROOT}${dir}" 2>/dev/null || true
-done
-
-# chroot(1) always chdirs to /; restore the caller's cwd when it exists inside
-# the chroot so relative paths keep working.
-exec chroot "${DATA_ROOT}" /bin/sh -c 'cd "$1" 2>/dev/null || cd /; shift; exec "$@"' sh "${CALLER_CWD}" "${PIP_BIN}" "$@"

package/src/__tests__/slack-reaction-approvals.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { reactionDecisionForEmoji } from "../runtime/routes/channel-route-shared.js";
-
-// =============================================================================
-// reactionDecisionForEmoji
-// =============================================================================
-
-describe("reactionDecisionForEmoji", () => {
-  test("maps +1 emoji to approve_once", () => {
-    const result = reactionDecisionForEmoji("+1");
-    expect(result).toEqual({
-      action: "approve_once",
-      source: "reaction",
-    });
-  });
-
-  test("maps thumbsup emoji to approve_once", () => {
-    const result = reactionDecisionForEmoji("thumbsup");
-    expect(result).toEqual({
-      action: "approve_once",
-      source: "reaction",
-    });
-  });
-
-  test("maps -1 emoji to reject", () => {
-    const result = reactionDecisionForEmoji("-1");
-    expect(result).toEqual({
-      action: "reject",
-      source: "reaction",
-    });
-  });
-
-  test("maps thumbsdown emoji to reject", () => {
-    const result = reactionDecisionForEmoji("thumbsdown");
-    expect(result).toEqual({
-      action: "reject",
-      source: "reaction",
-    });
-  });
-
-  test("alarm_clock emoji maps to approve_once (legacy compat)", () => {
-    const result = reactionDecisionForEmoji("alarm_clock");
-    expect(result).toEqual({
-      action: "approve_once",
-      source: "reaction",
-    });
-  });
-
-  test("white_check_mark emoji maps to approve_once (legacy compat)", () => {
-    const result = reactionDecisionForEmoji("white_check_mark");
-    expect(result).toEqual({
-      action: "approve_once",
-      source: "reaction",
-    });
-  });
-
-  test("unicode vocabulary: thumbs up, check mark, and alarm clock approve", () => {
-    for (const emoji of ["\u{1F44D}", "\u2705", "\u23F0"]) {
-      expect(reactionDecisionForEmoji(emoji)).toEqual({
-        action: "approve_once",
-        source: "reaction",
-      });
-    }
-  });
-
-  test("unicode vocabulary: thumbs down rejects", () => {
-    expect(reactionDecisionForEmoji("\u{1F44E}")).toEqual({
-      action: "reject",
-      source: "reaction",
-    });
-  });
-
-  test("a Discord custom emoji in mention form never resolves a decision", () => {
-    // A guild custom emoji can be named after a Slack decision word; the
-    // gateway forwards it as its mention form, which must stay unmapped.
-    expect(
-      reactionDecisionForEmoji("<:white_check_mark:999888777>"),
-    ).toBeNull();
-    expect(reactionDecisionForEmoji("<:thumbsup:999888777>")).toBeNull();
-  });
-
-  test("returns null for unknown emoji", () => {
-    const result = reactionDecisionForEmoji("tada");
-    expect(result).toBeNull();
-  });
-
-  test("returns null for an unmapped emoji", () => {
-    const result = reactionDecisionForEmoji("eyes");
-    expect(result).toBeNull();
-  });
-
-  test("returns null for an empty emoji name", () => {
-    const result = reactionDecisionForEmoji("");
-    expect(result).toBeNull();
-  });
-});

package/src/__tests__/slack-reaction-guardian-approval.test.ts

@@ -1,307 +0,0 @@
-/**
- * Tests for guardian approval-by-reaction on the guardian decision pipeline.
- *
- * A Slack emoji reaction (✅ / ❌) on a delivered approval card is routed
- * through `routeGuardianReply` exactly like a button press or text reply. The
- * emoji maps to an action and the reacted card's message id (`reactedMessageTs`)
- * resolves the target request via its canonical delivery record — so the
- * decision is applied precisely even when several cards are pending in the same
- * chat, with no clarification prompt.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-registry.js", () => ({
-  findConversation: (id: string) => _conversationMocks.get(id),
-}));
-
-import { createGuardianGatewaySim } from "./guardian-gateway-sim.js";
-
-const sim = createGuardianGatewaySim();
-mock.module("../channels/gateway-guardian-requests.js", () => sim.module);
-
-import type { Conversation } from "../daemon/conversation.js";
-import { initializeDb } from "../persistence/db-init.js";
-import {
-  inferDecisionActionFromFreeText,
-  routeGuardianReply,
-} from "../runtime/guardian-reply-router.js";
-import * as pendingInteractions from "../runtime/pending-interactions.js";
-
-await initializeDb();
-
-// ---------------------------------------------------------------------------
-// Constants & helpers
-// ---------------------------------------------------------------------------
-
-const GUARDIAN_USER = "U_GUARDIAN";
-const PRINCIPAL = "principal-1";
-const CHAT_ID = "D_GUARDIAN_DM";
-const TOOL_NAME = "execute_shell";
-
-function resetTables(): void {
-  sim.reset();
-  pendingInteractions.clear();
-  _conversationMocks.clear();
-}
-
-/**
- * Seed a pending tool-approval (gateway request + delivery + pending
- * interaction with a mock conversation) and return the mocked
- * `handleConfirmationResponse` so callers can assert it was driven.
- */
-function seedApproval(opts: {
-  requestId: string;
-  ts: string;
-  chatId?: string;
-  principal?: string;
-}): ReturnType<typeof mock> {
-  const chatId = opts.chatId ?? CHAT_ID;
-  const principal = opts.principal ?? PRINCIPAL;
-  const conversationId = `conv-${opts.requestId}`;
-
-  sim.seedRequest({
-    id: opts.requestId,
-    kind: "tool_approval",
-    sourceChannel: "slack",
-    sourceConversationId: conversationId,
-    requesterExternalUserId: "requester-1",
-    requesterChatId: chatId,
-    guardianExternalUserId: GUARDIAN_USER,
-    guardianPrincipalId: principal,
-    toolName: TOOL_NAME,
-    status: "pending",
-    expiresAt: Date.now() + 300_000,
-  });
-
-  sim.seedDelivery({
-    requestId: opts.requestId,
-    destinationChannel: "slack",
-    destinationChatId: chatId,
-    destinationMessageId: opts.ts,
-  });
-
-  const handleConfirmationResponse = mock(() => {});
-  _conversationMocks.set(conversationId, {
-    handleConfirmationResponse,
-    ensureActorScopedHistory: async () => {},
-  } as unknown as Conversation);
-  pendingInteractions.register(opts.requestId, {
-    conversationId,
-    kind: "confirmation",
-    confirmationDetails: {
-      toolName: TOOL_NAME,
-      input: { command: "echo hi" },
-      riskLevel: "high",
-      allowlistOptions: [{ label: "t", description: "t", pattern: "t" }],
-      scopeOptions: [{ label: "everywhere", scope: "everywhere" }],
-    },
-  });
-  return handleConfirmationResponse;
-}
-
-function reaction(opts: {
-  emoji: string;
-  reactedMessageTs?: string;
-  chatId?: string;
-  principal?: string;
-}): Parameters<typeof routeGuardianReply>[0] {
-  return {
-    messageText: "",
-    channel: "slack",
-    actor: {
-      actorPrincipalId: opts.principal ?? PRINCIPAL,
-      actorExternalUserId: GUARDIAN_USER,
-      channel: "slack",
-      guardianPrincipalId: opts.principal ?? PRINCIPAL,
-    },
-    conversationId: "guardian-conv",
-    reaction: {
-      op: "added" as const,
-      emoji: opts.emoji,
-      targetMessageId: opts.reactedMessageTs ?? "",
-    },
-    reactedMessageTs: opts.reactedMessageTs,
-    channelDeliveryContext: {
-      replyCallbackUrl: "https://gateway.test/deliver",
-      guardianChatId: opts.chatId ?? CHAT_ID,
-      assistantId: "self",
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Reaction routing
-// ---------------------------------------------------------------------------
-
-describe("routeGuardianReply / reactions", () => {
-  beforeEach(resetTables);
-
-  test("✅ on a delivered card approves the matching request", async () => {
-    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
-
-    const result = await routeGuardianReply(
-      reaction({ emoji: "white_check_mark", reactedMessageTs: "111.1" }),
-    );
-
-    expect(result.consumed).toBe(true);
-    expect(result.decisionApplied).toBe(true);
-    expect(result.type).toBe("canonical_decision_applied");
-    expect(sim.getRequest("req-1")?.status).toBe("approved");
-    expect(hcr).toHaveBeenCalledTimes(1);
-    expect(hcr.mock.calls[0]?.[0]).toBe("req-1");
-    expect(hcr.mock.calls[0]?.[1]).toBe("allow");
-  });
-
-  test("❌ on a delivered card rejects the matching request", async () => {
-    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
-
-    const result = await routeGuardianReply(
-      reaction({ emoji: "-1", reactedMessageTs: "111.1" }),
-    );
-
-    expect(result.decisionApplied).toBe(true);
-    expect(sim.getRequest("req-1")?.status).toBe("denied");
-    expect(hcr.mock.calls[0]?.[1]).toBe("deny");
-  });
-
-  test("a person-addressed delivery resolves through the reactor's own id", async () => {
-    // Person-addressed adapters (Discord) record the guardian's user id as
-    // the destination, while the reaction arrives addressed by its chat, so
-    // the chat probe misses and the actor-id probe must find the card.
-    const hcr = seedApproval({
-      requestId: "req-person",
-      ts: "300.3",
-      chatId: GUARDIAN_USER,
-    });
-
-    const result = await routeGuardianReply(
-      reaction({
-        emoji: "white_check_mark",
-        reactedMessageTs: "300.3",
-        chatId: "DM_CHANNEL_9",
-      }),
-    );
-
-    expect(result.consumed).toBe(true);
-    expect(result.decisionApplied).toBe(true);
-    expect(sim.getRequest("req-person")?.status).toBe("approved");
-    expect(hcr).toHaveBeenCalledTimes(1);
-  });
-
-  test("reacting on a specific card resolves only that card (disambiguates N>1)", async () => {
-    const hcrA = seedApproval({ requestId: "req-A", ts: "100.1" });
-    const hcrB = seedApproval({ requestId: "req-B", ts: "200.2" });
-
-    // React on card B's message — only B should resolve.
-    const result = await routeGuardianReply(
-      reaction({ emoji: "white_check_mark", reactedMessageTs: "200.2" }),
-    );
-
-    expect(result.requestId).toBe("req-B");
-    expect(sim.getRequest("req-B")?.status).toBe("approved");
-    expect(sim.getRequest("req-A")?.status).toBe("pending");
-    expect(hcrB).toHaveBeenCalledTimes(1);
-    expect(hcrA).not.toHaveBeenCalled();
-  });
-
-  test("a reaction on an unknown message is not consumed (left for transcript)", async () => {
-    seedApproval({ requestId: "req-1", ts: "111.1" });
-
-    const result = await routeGuardianReply(
-      reaction({ emoji: "white_check_mark", reactedMessageTs: "no-such-ts" }),
-    );
-
-    expect(result.consumed).toBe(false);
-    expect(result.type).toBe("not_consumed");
-    expect(sim.getRequest("req-1")?.status).toBe("pending");
-  });
-
-  test("an unknown emoji is not consumed", async () => {
-    seedApproval({ requestId: "req-1", ts: "111.1" });
-
-    const result = await routeGuardianReply(
-      reaction({ emoji: "tada", reactedMessageTs: "111.1" }),
-    );
-
-    expect(result.consumed).toBe(false);
-    expect(sim.getRequest("req-1")?.status).toBe("pending");
-  });
-
-  test("a reaction without a reacted message id is not consumed", async () => {
-    seedApproval({ requestId: "req-1", ts: "111.1" });
-
-    const result = await routeGuardianReply(
-      reaction({ emoji: "white_check_mark" }),
-    );
-
-    expect(result.consumed).toBe(false);
-  });
-
-  test("a reaction from a different principal is surfaced, not silently dropped", async () => {
-    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
-
-    const result = await routeGuardianReply(
-      reaction({
-        emoji: "white_check_mark",
-        reactedMessageTs: "111.1",
-        principal: "someone-else",
-      }),
-    );
-
-    // Consumed with a user-facing reply, request untouched, side effect not run.
-    expect(result.consumed).toBe(true);
-    expect(result.decisionApplied).toBe(false);
-    expect(result.replyText).toMatch(/permission/i);
-    expect(sim.getRequest("req-1")?.status).toBe("pending");
-    expect(hcr).not.toHaveBeenCalled();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Free-text decision inference (no request code)
-// ---------------------------------------------------------------------------
-
-describe("inferDecisionActionFromFreeText / introduction verbs", () => {
-  // Regression: a bare "block" on an access request must map to the block
-  // action (revoke), not the weaker generic reject (leave_unverified).
-  test('"block" maps to block for access requests, reject elsewhere', () => {
-    expect(inferDecisionActionFromFreeText("block", "access_request")).toBe(
-      "block",
-    );
-    expect(inferDecisionActionFromFreeText("Block!", "access_request")).toBe(
-      "block",
-    );
-    expect(inferDecisionActionFromFreeText("block")).toBe("reject");
-    expect(inferDecisionActionFromFreeText("block", "tool_approval")).toBe(
-      "reject",
-    );
-  });
-
-  test("trust and verify verbs are recognized for access requests", () => {
-    expect(inferDecisionActionFromFreeText("trust", "access_request")).toBe(
-      "trust",
-    );
-    expect(inferDecisionActionFromFreeText("verify", "access_request")).toBe(
-      "verify_code",
-    );
-    // Unknown outside access requests — falls through to null (no cue).
-    expect(inferDecisionActionFromFreeText("trust")).toBeNull();
-  });
-
-  test("generic vocabulary keeps its semantics per kind", () => {
-    expect(inferDecisionActionFromFreeText("no", "access_request")).toBe(
-      "leave_unverified",
-    );
-    expect(inferDecisionActionFromFreeText("reject", "access_request")).toBe(
-      "leave_unverified",
-    );
-    expect(inferDecisionActionFromFreeText("yes", "access_request")).toBe(
-      "approve_once",
-    );
-    expect(inferDecisionActionFromFreeText("no", "tool_approval")).toBe(
-      "reject",
-    );
-  });
-});