@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.0",
+  "version": "0.10.1-dev.202606240317.ea25efe",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -41,6 +41,7 @@
     "@qdrant/js-client-rest": "1.17.0",
     "@resvg/resvg-js": "2.6.2",
     "@sentry/node": "10.43.0",
+    "@slack/types": "2.21.1",
     "@vellumai/ces-client": "file:../packages/ces-client",
     "@vellumai/credential-storage": "file:../packages/credential-storage",
     "@vellumai/egress-proxy": "file:../packages/egress-proxy",

package/scripts/memory-inspect.ts

@@ -22,10 +22,13 @@ import {
   queryNodes,
 } from "../src/memory/graph/store.js";
 import type { ScoredNode } from "../src/memory/graph/types.js";
-import { initQdrantClient, resolveQdrantUrl } from "../src/memory/qdrant-client.js";
+import {
+  initQdrantClient,
+  resolveQdrantUrl,
+} from "../src/memory/qdrant-client.js";
 
 // Initialize DB and Qdrant before anything else
-initializeDb();
+await initializeDb();
 const config = getConfig();
 try {
   initQdrantClient({
@@ -83,7 +86,7 @@ async function main() {
   } else if (args.includes("--narrative")) {
     await runNarrative();
   } else if (args.includes("--decay")) {
-    runDecay();
+    await runDecay();
   } else {
     console.log(`Memory Graph Inspector
 
@@ -211,7 +214,8 @@ async function showStats() {
 }
 
 async function showContextLoad() {
-  const { loadContextMemory } = await import("../src/memory/graph/retriever.js");
+  const { loadContextMemory } =
+    await import("../src/memory/graph/retriever.js");
 
   console.log("\n  Simulating context load (conversation start)...\n");
 
@@ -227,7 +231,8 @@ async function showContextLoad() {
   console.log(`  Triggered: ${result.triggeredNodes.length} triggers fired`);
 
   // Show assembled context
-  const { assembleContextBlock } = await import("../src/memory/graph/injection.js");
+  const { assembleContextBlock } =
+    await import("../src/memory/graph/injection.js");
   const block = assembleContextBlock(result.nodes, {
     serendipityNodes: result.serendipityNodes,
   });
@@ -245,7 +250,8 @@ async function showContextLoad() {
 
 async function showQuery(query: string) {
   const { embedWithRetry } = await import("../src/memory/embed.js");
-  const { searchGraphNodes } = await import("../src/memory/graph/graph-search.js");
+  const { searchGraphNodes } =
+    await import("../src/memory/graph/graph-search.js");
   const { getNodesByIds } = await import("../src/memory/graph/store.js");
 
   console.log(`\n  Searching: "${query}"\n`);
@@ -369,7 +375,8 @@ function showNode(nodeId: string) {
 async function showTurn(userMessage: string) {
   const { retrieveForTurn } = await import("../src/memory/graph/retriever.js");
   const { InContextTracker } = await import("../src/memory/graph/injection.js");
-  const { assembleInjectionBlock } = await import("../src/memory/graph/injection.js");
+  const { assembleInjectionBlock } =
+    await import("../src/memory/graph/injection.js");
 
   const tracker = new InContextTracker();
 
@@ -440,7 +447,8 @@ async function runBootstrap() {
 }
 
 async function runJournalBootstrap() {
-  const { bootstrapFromJournal } = await import("../src/memory/graph/bootstrap.js");
+  const { bootstrapFromJournal } =
+    await import("../src/memory/graph/bootstrap.js");
 
   console.log("\n  Extracting from journal files...\n");
   const result = await bootstrapFromJournal();
@@ -450,7 +458,8 @@ async function runJournalBootstrap() {
 }
 
 async function runConsolidate() {
-  const { runConsolidation } = await import("../src/memory/graph/consolidation.js");
+  const { runConsolidation } =
+    await import("../src/memory/graph/consolidation.js");
   console.log("\n  Running consolidation...\n");
   const result = await runConsolidation("default", config);
   console.log(
@@ -469,7 +478,8 @@ async function runConsolidate() {
 }
 
 async function runPatterns() {
-  const { runPatternScan } = await import("../src/memory/graph/pattern-scan.js");
+  const { runPatternScan } =
+    await import("../src/memory/graph/pattern-scan.js");
   console.log("\n  Running pattern scan...\n");
   const result = await runPatternScan("default", config);
   console.log(
@@ -481,7 +491,8 @@ async function runPatterns() {
 }
 
 async function runNarrative() {
-  const { runNarrativeRefinement } = await import("../src/memory/graph/narrative.js");
+  const { runNarrativeRefinement } =
+    await import("../src/memory/graph/narrative.js");
   console.log("\n  Running narrative refinement...\n");
   const result = await runNarrativeRefinement("default", config);
   console.log(
@@ -500,9 +511,8 @@ async function runNarrative() {
   console.log();
 }
 
-function runDecay() {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const { runDecayTick } = require("../src/memory/graph/decay.js") as typeof import("../src/memory/graph/decay.js");
+async function runDecay() {
+  const { runDecayTick } = await import("../src/memory/graph/decay.js");
   console.log("\n  Running decay tick...\n");
   const result = runDecayTick("default");
   console.log(`  Nodes processed: ${result.nodesProcessed}`);

package/scripts/test.sh

@@ -169,6 +169,7 @@ printf '%s\n' "${test_files[@]}" | xargs -P "${WORKERS}" -I {} bash -c '
 
   safe_name="$(echo "${test_file}" | tr "/" "_")"
   out_file="${results_dir}/${safe_name}.out"
+  base="$(basename "${test_file}")"
 
   coverage_args=""
   if [[ "${coverage_enabled}" == "true" ]]; then
@@ -185,28 +186,48 @@ printf '%s\n' "${test_files[@]}" | xargs -P "${WORKERS}" -I {} bash -c '
     timeout_cmd="gtimeout"
   fi
 
-  start_ms=$(perl -MTime::HiRes=time -e "printf \"%d\", time*1000")
-
-  if [[ -n "${timeout_cmd}" ]]; then
-    if [[ "${exclude_exp}" == "true" ]]; then
-      "${timeout_cmd}" -k 10 "${per_test_timeout}" bun test ${coverage_args} --test-name-pattern "^(?!.*\\[experimental\\])" "${test_file}" > "${out_file}" 2>&1
-    else
-      "${timeout_cmd}" -k 10 "${per_test_timeout}" bun test ${coverage_args} "${test_file}" > "${out_file}" 2>&1
-    fi
-  else
-    if [[ "${exclude_exp}" == "true" ]]; then
-      bun test ${coverage_args} --test-name-pattern "^(?!.*\\[experimental\\])" "${test_file}" > "${out_file}" 2>&1
+  # Run the test file in its own bun process. Wrapped in a function so a
+  # transient infrastructure crash can be retried without duplicating the
+  # four-way (timeout × experimental-filter) invocation.
+  run_bun_test() {
+    if [[ -n "${timeout_cmd}" ]]; then
+      if [[ "${exclude_exp}" == "true" ]]; then
+        "${timeout_cmd}" -k 10 "${per_test_timeout}" bun test ${coverage_args} --test-name-pattern "^(?!.*\\[experimental\\])" "${test_file}" > "${out_file}" 2>&1
+      else
+        "${timeout_cmd}" -k 10 "${per_test_timeout}" bun test ${coverage_args} "${test_file}" > "${out_file}" 2>&1
+      fi
     else
-      bun test ${coverage_args} "${test_file}" > "${out_file}" 2>&1
+      if [[ "${exclude_exp}" == "true" ]]; then
+        bun test ${coverage_args} --test-name-pattern "^(?!.*\\[experimental\\])" "${test_file}" > "${out_file}" 2>&1
+      else
+        bun test ${coverage_args} "${test_file}" > "${out_file}" 2>&1
+      fi
     fi
-  fi
+  }
+
+  start_ms=$(perl -MTime::HiRes=time -e "printf \"%d\", time*1000")
+
+  run_bun_test
   exit_code=$?
 
+  # Retry once on a transient bun loader/runtime crash. Bun occasionally aborts
+  # a worker before its tests run — e.g. "# Unhandled error between tests" with
+  # "error: ENOENT reading <corrupted path>" — failing the whole job even though
+  # the file is green on a clean process. Such a crash truncates the run before
+  # any assertion executes, so it prints no "(fail)" line; genuine assertion
+  # failures do, and are reported immediately without a retry (fast feedback, no
+  # masking of intermittent real failures). Timeouts (124/137) are handled by the
+  # hang branch below, not here.
+  if [[ ${exit_code} -ne 0 && ${exit_code} -ne 124 && ${exit_code} -ne 137 ]] \
+     && ! grep -q "^(fail)" "${out_file}" 2>/dev/null; then
+    echo "  ↻ ${base} (transient crash, exit ${exit_code} — retrying once)"
+    run_bun_test
+    exit_code=$?
+  fi
+
   end_ms=$(perl -MTime::HiRes=time -e "printf \"%d\", time*1000")
   elapsed=$(( end_ms - start_ms ))
 
-  base="$(basename "${test_file}")"
-
   # Record duration for longest-first scheduling in future runs.
   # Write the repo-relative path (not the basename) so the lookup in future
   # runs disambiguates files that share a basename across directories.

package/src/__tests__/access-request-seed-content-blocks.test.ts

@@ -1,8 +1,30 @@
 import { describe, expect, test } from "bun:test";
 
 import { parseAccessRequestPayload } from "../notifications/access-request-copy.js";
+import type {
+  ApprovalCardBlock,
+  ApprovalCardFallbackBlock,
+  ApprovalCardSurfaceBlock,
+} from "../notifications/approval-card-builder.js";
 import { buildAccessRequestSeedContentBlocks } from "../notifications/approval-card-data.js";
 
+// The builder returns a schema-derived `ApprovalCardBlock[]`, so tests narrow by
+// the block's discriminant instead of casting to `Record<string, unknown>`.
+function surfaceOf(blocks: ApprovalCardBlock[]): ApprovalCardSurfaceBlock {
+  const block = blocks[0];
+  if (block?.type !== "ui_surface") {
+    throw new Error("expected a ui_surface block at index 0");
+  }
+  return block;
+}
+function textOf(blocks: ApprovalCardBlock[]): ApprovalCardFallbackBlock {
+  const block = blocks[1];
+  if (block?.type !== "text") {
+    throw new Error("expected a text fallback block at index 1");
+  }
+  return block;
+}
+
 describe("buildAccessRequestSeedContentBlocks", () => {
   const basePayload: Record<string, unknown> = {
     requestId: "req-123",
@@ -20,173 +42,131 @@ describe("buildAccessRequestSeedContentBlocks", () => {
   test("produces a ui_surface block and a text fallback block", () => {
     const blocks = buildAccessRequestSeedContentBlocks(basePayload);
     expect(blocks).toHaveLength(2);
-    expect((blocks[0] as Record<string, unknown>).type).toBe("ui_surface");
-    expect((blocks[1] as Record<string, unknown>).type).toBe("text");
+    expect(surfaceOf(blocks).type).toBe("ui_surface");
+    expect(textOf(blocks).type).toBe("text");
+    // The fallback block is flagged so surface-capable clients skip it.
+    expect(textOf(blocks)._surfaceFallback).toBe(true);
   });
 
   test("card surface has correct surfaceType and surfaceId", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const surface = blocks[0] as Record<string, unknown>;
+    const surface = surfaceOf(buildAccessRequestSeedContentBlocks(basePayload));
     expect(surface.surfaceType).toBe("card");
     expect(surface.surfaceId).toBe("access-request-req-123");
     expect(surface.title).toBe("Access Request");
   });
 
   test("card data uses actorDisplayName as title", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const surface = blocks[0] as Record<string, unknown>;
-    const data = surface.data as Record<string, unknown>;
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks(basePayload),
+    );
     expect(data.title).toBe("Alice");
     expect(data.subtitle).toBe("Requesting access to the assistant");
   });
 
   test("card data falls back to senderIdentifier when no displayName", () => {
-    const payload = { ...basePayload, actorDisplayName: undefined };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    expect(data.title).toBe("U999");
+    const blocks = buildAccessRequestSeedContentBlocks({
+      ...basePayload,
+      actorDisplayName: undefined,
+    });
+    expect(surfaceOf(blocks).data.title).toBe("U999");
   });
 
   test("card data falls back to 'Someone' when no identity", () => {
-    const payload = {
+    const blocks = buildAccessRequestSeedContentBlocks({
       ...basePayload,
       actorDisplayName: undefined,
       senderIdentifier: undefined,
-    };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    expect(data.title).toBe("Someone");
+    });
+    expect(surfaceOf(blocks).data.title).toBe("Someone");
   });
 
   test("includes username and source in metadata", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    const metadata = data.metadata as Array<{ label: string; value: string }>;
-    expect(metadata).toContainEqual({
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks(basePayload),
+    );
+    expect(data.metadata).toContainEqual({
       label: "Username",
       value: "@alice",
     });
-    expect(metadata).toContainEqual({
+    expect(data.metadata).toContainEqual({
       label: "Source",
       value: "Slack — #C01ABC",
     });
   });
 
   test("DM channel renders as Direct message", () => {
-    const payload = { ...basePayload, conversationExternalId: "D01XYZ" };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    const metadata = data.metadata as Array<{ label: string; value: string }>;
-    expect(metadata).toContainEqual({
+    const blocks = buildAccessRequestSeedContentBlocks({
+      ...basePayload,
+      conversationExternalId: "D01XYZ",
+    });
+    expect(surfaceOf(blocks).data.metadata).toContainEqual({
       label: "Source",
       value: "Slack — Direct message",
     });
   });
 
   test("body includes message preview when present", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks(basePayload),
+    );
     expect(data.body).toContain("Hello, I need help with something");
   });
 
   test("body includes trust signal warnings", () => {
-    const payload = {
-      ...basePayload,
-      isStranger: true,
-      isRestricted: true,
-      previousMemberStatus: "revoked",
-    };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    const body = data.body as string;
-    expect(body).toContain("External Slack user");
-    expect(body).toContain("Guest / restricted account");
-    expect(body).toContain("previously revoked");
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks({
+        ...basePayload,
+        isStranger: true,
+        isRestricted: true,
+        previousMemberStatus: "revoked",
+      }),
+    );
+    expect(data.body).toContain("External Slack user");
+    expect(data.body).toContain("Guest / restricted account");
+    expect(data.body).toContain("previously revoked");
   });
 
   test("body includes Slack message permalink", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    const body = data.body as string;
-    expect(body).toContain("View message");
-    expect(body).toContain(
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks(basePayload),
+    );
+    expect(data.body).toContain("View message");
+    expect(data.body).toContain(
       "https://slack.com/archives/C01ABC/p1700000000000100",
     );
   });
 
   test("text fallback block contains contract text", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const textBlock = blocks[1] as Record<string, unknown>;
-    expect(textBlock.type).toBe("text");
-    const text = textBlock.text as string;
-    expect(text).toContain("requesting access to the assistant");
-    expect(text).toContain("ABC123");
+    const textBlock = textOf(buildAccessRequestSeedContentBlocks(basePayload));
+    expect(textBlock.text).toContain("requesting access to the assistant");
+    expect(textBlock.text).toContain("ABC123");
   });
 
   test("body shows fallback when no preview/warnings/permalink", () => {
-    const payload = {
+    const blocks = buildAccessRequestSeedContentBlocks({
       requestId: "req-456",
       requestCode: "XYZ",
       senderIdentifier: "someone",
-    };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    expect(data.body).toBe("No additional context available.");
+    });
+    expect(surfaceOf(blocks).data.body).toBe(
+      "No additional context available.",
+    );
   });
 
   test("surface block includes approve/reject actions when requestId present", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const surface = blocks[0] as Record<string, unknown>;
-    const actions = surface.actions as Array<{
-      id: string;
-      label: string;
-      style: string;
-    }>;
-    expect(actions).toHaveLength(2);
-    expect(actions[0]).toEqual({
-      id: "apr:req-123:approve_once",
-      label: "Approve",
-      style: "primary",
-    });
-    expect(actions[1]).toEqual({
-      id: "apr:req-123:reject",
-      label: "Reject",
-      style: "destructive",
-    });
+    const surface = surfaceOf(buildAccessRequestSeedContentBlocks(basePayload));
+    expect(surface.actions).toEqual([
+      { id: "apr:req-123:approve_once", label: "Approve", style: "primary" },
+      { id: "apr:req-123:reject", label: "Reject", style: "destructive" },
+    ]);
   });
 
   test("surface block omits actions when requestId is missing", () => {
-    const payload = {
+    const blocks = buildAccessRequestSeedContentBlocks({
       ...basePayload,
       requestId: undefined,
-    };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const surface = blocks[0] as Record<string, unknown>;
-    expect(surface.actions).toBeUndefined();
+    });
+    expect(surfaceOf(blocks).actions).toBeUndefined();
   });
 
   test("parseAccessRequestPayload extracts typed fields", () => {

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

@@ -36,7 +36,7 @@ const { getDb } = await import("../memory/db-connection.js");
 const { initializeDb } = await import("../memory/db-init.js");
 const { activationSessions } = await import("../memory/schema.js");
 
-initializeDb();
+await initializeDb();
 
 /** Seed the workspace BOOTSTRAP.md with the unmodified generic template so the
  *  one-shot reseed inside `applyBootstrapTemplate` fires. */

package/src/__tests__/actor-token-service.test.ts

@@ -29,6 +29,17 @@ mock.module("../config/env.js", () => ({
   checkUnrecognizedEnvVars: () => {},
 }));
 
+// No gateway in tests: force the reader to miss so resolution exercises the
+// local-store bootstrap fallback deterministically.
+let fakeGuardianDelivery: { principalId?: string | null } | null = null;
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () =>
+    fakeGuardianDelivery ? [fakeGuardianDelivery] : null,
+  guardianForChannel: (list: { principalId?: string | null }[]) => list[0],
+  invalidateGuardianDeliveryCache: () => {},
+  onContactChange: () => {},
+}));
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { resetExternalAssistantIdCache } from "../runtime/auth/external-assistant-id.js";
@@ -46,13 +57,14 @@ import { resetDbForTesting } from "./db-test-helpers.js";
 const TEST_KEY = Buffer.from("test-signing-key-32-bytes-long!!");
 
 // ---------------------------------------------------------------------------
-initializeDb();
+await initializeDb();
 
-beforeEach(() => {
+beforeEach(async () => {
   initAuthSigningKey(TEST_KEY);
   resetExternalAssistantIdCache();
+  fakeGuardianDelivery = null;
   resetDbForTesting();
-  initializeDb();
+  await initializeDb();
 });
 
 // ---------------------------------------------------------------------------
@@ -60,8 +72,8 @@ beforeEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("resolveLocalTrustContext", () => {
-  test("falls back to minimal trust context when no vellum binding exists", () => {
-    const ctx = resolveLocalTrustContext();
+  test("falls back to minimal trust context when no vellum binding exists", async () => {
+    const ctx = await resolveLocalTrustContext();
     expect(ctx.sourceChannel).toBe("vellum");
   });
 });
@@ -71,38 +83,48 @@ describe("resolveLocalTrustContext", () => {
 // ---------------------------------------------------------------------------
 
 describe("resolveLocalAuthContext", () => {
-  test("returns AuthContext with local principal type", () => {
-    const ctx = resolveLocalAuthContext("session-123");
+  test("returns AuthContext with local principal type", async () => {
+    const ctx = await resolveLocalAuthContext("session-123");
     expect(ctx.principalType).toBe("local");
   });
 
-  test("subject follows local:self:<conversationId> pattern", () => {
-    const ctx = resolveLocalAuthContext("session-abc");
+  test("subject follows local:self:<conversationId> pattern", async () => {
+    const ctx = await resolveLocalAuthContext("session-abc");
     expect(ctx.subject).toBe("local:self:session-abc");
   });
 
-  test("assistantId is always self", () => {
-    const ctx = resolveLocalAuthContext("session-123");
+  test("assistantId is always self", async () => {
+    const ctx = await resolveLocalAuthContext("session-123");
     expect(ctx.assistantId).toBe("self");
   });
 
-  test("uses local_v1 scope profile with local.all scope", () => {
-    const ctx = resolveLocalAuthContext("session-123");
+  test("uses local_v1 scope profile with local.all scope", async () => {
+    const ctx = await resolveLocalAuthContext("session-123");
     expect(ctx.scopeProfile).toBe("local_v1");
     expect(ctx.scopes.has("local.all")).toBe(true);
   });
 
-  test("actorPrincipalId is undefined when no vellum binding exists", () => {
+  test("actorPrincipalId is undefined when no vellum binding exists", async () => {
     const db = getDb();
     db.run("DELETE FROM contact_channels");
     db.run("DELETE FROM contacts");
 
-    const ctx = resolveLocalAuthContext("session-123");
+    const ctx = await resolveLocalAuthContext("session-123");
     expect(ctx.actorPrincipalId).toBeUndefined();
   });
 
-  test("conversationId matches the provided argument", () => {
-    const ctx = resolveLocalAuthContext("my-session");
+  test("resolves the guardian principal from the gateway when available", async () => {
+    const db = getDb();
+    db.run("DELETE FROM contact_channels");
+    db.run("DELETE FROM contacts");
+    fakeGuardianDelivery = { principalId: "gateway-guardian-id" };
+
+    const ctx = await resolveLocalAuthContext("session-123");
+    expect(ctx.actorPrincipalId).toBe("gateway-guardian-id");
+  });
+
+  test("conversationId matches the provided argument", async () => {
+    const ctx = await resolveLocalAuthContext("my-session");
     expect(ctx.conversationId).toBe("my-session");
   });
 });

package/src/__tests__/agent-loop-callsite-precedence.test.ts

@@ -9,8 +9,7 @@
  * for these knobs is silently ignored.
  *
  * Precedence (highest wins):
- *   1. Per-turn explicit (from `resolveSystemPrompt`'s
- *      `resolved.maxTokens` / `resolved.model`)
+ *   1. Per-run explicit (from `run()`'s `model` param)
  *   2. Call-site resolved values (from `resolveCallSiteConfig` via the
  *      normalizer)
  *   3. Conversation defaults (`this.config.*`, from `llm.default`)
@@ -33,7 +32,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => ({ llm: mockLlmConfig }),
 }));
 
-import type { ResolvedSystemPrompt } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import { LLMSchema } from "../config/schemas/llm.js";
 import { RetryProvider } from "../providers/retry.js";
@@ -298,41 +296,4 @@ describe("AgentLoop — call-site precedence", () => {
     // No callSite → loop sets the wire-format thinking directly.
     expect(config.thinking).toEqual({ type: "adaptive" });
   });
-
-  test("per-turn resolveSystemPrompt.maxTokens wins over both call-site and default", async () => {
-    setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-default",
-        maxTokens: 64000,
-      },
-      callSites: { mainAgent: { maxTokens: 4096 } },
-    });
-
-    const { provider, lastConfig } = makePipeline("anthropic");
-    const resolveSystemPrompt = (): ResolvedSystemPrompt => ({
-      systemPrompt: "per-turn system",
-      maxTokens: 8192,
-    });
-
-    const loop = new AgentLoop({
-      provider: provider,
-      systemPrompt: "system",
-      conversationId: "test-conversation",
-      config: { maxTokens: 64000 },
-      resolveSystemPrompt: resolveSystemPrompt,
-    });
-
-    await loop.run({
-      requestId: "test-request",
-      messages: [userMessage],
-      onEvent: () => {},
-      trust: { sourceChannel: "vellum", trustClass: "unknown" },
-      callSite: "mainAgent",
-    });
-
-    // Per-turn explicit value beats both the call-site (4096) and the
-    // default (64000).
-    expect(lastConfig()!.max_tokens).toBe(8192);
-  });
 });

package/src/__tests__/agent-loop-compaction-events.test.ts

@@ -104,7 +104,6 @@ function fakeCompaction(
 ): { trust: TrustContext } {
   createContextWindowManager({
     provider: { name: "mock-provider" } as unknown as Provider,
-    systemPrompt: "system",
     config: {} as unknown as ContextWindowConfig,
     conversationId,
   });

package/src/__tests__/agent-loop-compaction-strip.test.ts

@@ -106,7 +106,6 @@ function installCapturingManager(capture: CompactionInputCapture): {
 } {
   createContextWindowManager({
     provider: { name: "mock-provider" } as unknown as Provider,
-    systemPrompt: "system",
     config: {} as unknown as ContextWindowConfig,
     conversationId: CONVERSATION_ID,
   });