@vellumai/assistant 0.11.3 → 0.11.4-staging.2

package/src/__tests__/document-append-idempotency.test.ts

@@ -0,0 +1,233 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDocumentById } from "../documents/document-store.js";
+import { getSqlite } from "../persistence/db-connection.js";
+import {
+  executeDocumentCreate,
+  executeDocumentUpdate,
+} from "../tools/document/document-tool.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+
+const CONVERSATION_ID = "conv-current";
+
+/** Long enough to clear the store's minimum-duplicate-length floor. */
+const OPENING =
+  "Remote work reshaped the office long before anyone had a name for it.";
+
+function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    workingDir: "/tmp/project",
+    conversationId: CONVERSATION_ID,
+    trustClass: "trusted_contact",
+    executionChannel: "slack",
+    sendToClient: () => {},
+    ...overrides,
+  };
+}
+
+function parseResult<T>(result: ToolExecutionResult): T {
+  return JSON.parse(result.content) as T;
+}
+
+function bootstrapDocumentTables(): void {
+  resetDbForTesting();
+  const raw = getSqlite();
+  raw.exec(/*sql*/ `
+    DROP TABLE IF EXISTS document_conversations;
+    DROP TABLE IF EXISTS documents;
+    DROP TABLE IF EXISTS conversations;
+
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)
+    );
+
+    CREATE TABLE documents (
+      surface_id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      workspace_path TEXT
+    );
+
+    CREATE TABLE document_conversations (
+      surface_id TEXT NOT NULL,
+      conversation_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, conversation_id),
+      FOREIGN KEY (surface_id) REFERENCES documents(surface_id) ON DELETE CASCADE
+    );
+  `);
+  raw
+    .query(`INSERT OR IGNORE INTO conversations (id, created_at) VALUES (?, ?)`)
+    .run(CONVERSATION_ID, Date.now());
+}
+
+function seedDocument(surfaceId: string, content: string): void {
+  const now = Date.now();
+  const raw = getSqlite();
+  raw
+    .query(
+      `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      surfaceId,
+      CONVERSATION_ID,
+      "Draft",
+      content,
+      content.split(/\s+/).filter(Boolean).length,
+      now,
+      now,
+    );
+  raw
+    .query(
+      `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
+    )
+    .run(surfaceId, CONVERSATION_ID, now);
+}
+
+describe("document append idempotency", () => {
+  beforeEach(() => {
+    bootstrapDocumentTables();
+  });
+
+  test("an opening passed to both document_create and the first append lands once", () => {
+    const created = executeDocumentCreate(
+      { title: "Draft", initial_content: `# Draft\n\n${OPENING}` },
+      makeContext(),
+    );
+    const surfaceId = parseResult<{ surface_id: string }>(created).surface_id;
+
+    const result = executeDocumentUpdate(
+      {
+        surface_id: surfaceId,
+        content: `# Draft\n\n${OPENING}\n\nThe second paragraph carries the argument forward.`,
+        mode: "append",
+      },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(getDocumentById(surfaceId)?.content).toBe(
+      `# Draft\n\n${OPENING}\n\nThe second paragraph carries the argument forward.`,
+    );
+  });
+
+  test("an append that only restates the tail writes nothing", () => {
+    seedDocument("doc-restate", `# Draft\n\n${OPENING}`);
+
+    const result = executeDocumentUpdate(
+      { surface_id: "doc-restate", content: OPENING, mode: "append" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const body = parseResult<{ success: boolean; message: string }>(result);
+    expect(body.success).toBe(true);
+    expect(body.message).toBe(
+      "Nothing appended: the content is already at the end of the document",
+    );
+    expect(getDocumentById("doc-restate")?.content).toBe(
+      `# Draft\n\n${OPENING}`,
+    );
+  });
+
+  test("the client is told what landed, not what was submitted", () => {
+    seedDocument("doc-client", OPENING);
+    const sent: { markdown: unknown; mode: unknown }[] = [];
+
+    executeDocumentUpdate(
+      {
+        surface_id: "doc-client",
+        content: `${OPENING}\n\nAnd then the rest.`,
+        mode: "append",
+      },
+      makeContext({
+        sendToClient: (message) => {
+          if (message.type === "document_editor_update") {
+            sent.push({ markdown: message.markdown, mode: message.mode });
+          }
+        },
+      }),
+    );
+
+    expect(sent).toEqual([{ markdown: "And then the rest.", mode: "append" }]);
+  });
+
+  // ── Legitimate repetition the guard must not eat ──────────────────
+
+  test("keeps a short repeated line, even back to back", () => {
+    seedDocument("doc-refrain", "## Checklist\n\nTODO");
+
+    executeDocumentUpdate(
+      { surface_id: "doc-refrain", content: "TODO\n\nTODO", mode: "append" },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-refrain")?.content).toBe(
+      "## Checklist\n\nTODO\n\nTODO\n\nTODO",
+    );
+  });
+
+  test("keeps a repeated heading followed by new prose", () => {
+    seedDocument("doc-heading", "# Weekly Notes\n\n## Monday");
+
+    executeDocumentUpdate(
+      {
+        surface_id: "doc-heading",
+        content: "## Monday\n\nShipped the importer.",
+        mode: "append",
+      },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-heading")?.content).toBe(
+      "# Weekly Notes\n\n## Monday\n\n## Monday\n\nShipped the importer.",
+    );
+  });
+
+  test("keeps a long paragraph that repeats something other than the tail", () => {
+    seedDocument("doc-midway", `${OPENING}\n\nA later paragraph ends the doc.`);
+
+    executeDocumentUpdate(
+      { surface_id: "doc-midway", content: OPENING, mode: "append" },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-midway")?.content).toBe(
+      `${OPENING}\n\nA later paragraph ends the doc.\n\n${OPENING}`,
+    );
+  });
+
+  test("keeps content whose repetition starts partway into the append", () => {
+    seedDocument("doc-partway", `# Draft\n\n${OPENING}`);
+
+    executeDocumentUpdate(
+      {
+        surface_id: "doc-partway",
+        content: `A fresh lead-in.\n\n${OPENING}`,
+        mode: "append",
+      },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-partway")?.content).toBe(
+      `# Draft\n\n${OPENING}\n\nA fresh lead-in.\n\n${OPENING}`,
+    );
+  });
+
+  test("replace mode is never deduplicated", () => {
+    seedDocument("doc-replace", OPENING);
+
+    executeDocumentUpdate(
+      { surface_id: "doc-replace", content: OPENING, mode: "replace" },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-replace")?.content).toBe(OPENING);
+  });
+});

package/src/__tests__/edit-propagation.test.ts

@@ -145,7 +145,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "new text",
     });
@@ -187,7 +186,6 @@ describe("Slack edit propagation", () => {
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
       sourceThreadId: threadTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "new text",
     });
@@ -216,7 +214,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "first edit",
     });
@@ -239,7 +236,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "second edit",
     });
@@ -272,7 +268,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       // Same text as stored -- simulates a Slack unfurl `message_changed`
       // where only attachments changed.
@@ -313,7 +308,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "edited searchable text",
     });
@@ -341,7 +335,6 @@ describe("Slack edit propagation", () => {
       // sourceMessageId points at a ts that was never stored.
       externalMessageId: nextEditEventId(),
       sourceMessageId: "9999.0000",
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "new text",
     });

package/src/__tests__/helpers/mock-actor-context.ts

@@ -0,0 +1,49 @@
+/**
+ * Typed fixture factories for actor identity in tests.
+ *
+ * A fixture built here is a complete, type-checked `TrustContext` or
+ * `AuthContext` with conservative defaults; a test overrides only the fields
+ * its scenario is about, and the compiler guards the rest. Hand-rolled
+ * literals cannot make that guarantee: a missing required field needs a cast
+ * to satisfy the checker, and the cast then hides every other mistake in the
+ * literal.
+ *
+ * Type-only imports keep this helper out of the runtime import graph, per the
+ * test-machinery isolation rules in `assistant/CLAUDE.md`.
+ */
+
+import type { TrustContext } from "../../daemon/trust-context-types.js";
+import type { AuthContext, Scope } from "../../runtime/auth/types.js";
+
+/**
+ * A complete `TrustContext`. Defaults to the guardian on the vellum channel;
+ * pass overrides for anything the test cares about.
+ */
+export function mockTrustContext(
+  overrides: Partial<TrustContext> = {},
+): TrustContext {
+  return {
+    sourceChannel: "vellum",
+    trustClass: "guardian",
+    ...overrides,
+  };
+}
+
+/**
+ * A complete `AuthContext`. Defaults to a local principal with no scopes, the
+ * conservative shape, so a test that forgets to opt in exercises the
+ * restrictive branch rather than a silently permissive one.
+ */
+export function mockAuthContext(
+  overrides: Partial<AuthContext> = {},
+): AuthContext {
+  return {
+    subject: "local:self:test",
+    principalType: "local",
+    assistantId: "self",
+    scopeProfile: "local_v1",
+    scopes: new Set<Scope>(),
+    policyEpoch: 0,
+    ...overrides,
+  };
+}

package/src/__tests__/helpers/mock-conversation.ts

@@ -26,7 +26,19 @@ import type { ChannelCapabilities } from "../../daemon/conversation-runtime-asse
 export function asConversation<TExtra extends object = object>(
   mock: Partial<Conversation> & TExtra,
 ): Conversation & TExtra {
-  return mock as unknown as Conversation & TExtra;
+  // Trust accessors, derived from the double's own fields exactly as the real
+  // class derives them, so a double that sets (or later mutates) the fields
+  // resolves the same values production would. Supplied only when the double
+  // does not bring its own, and reading through `merged` rather than `mock`
+  // so a test that reassigns the fields on the returned object is honoured.
+  const merged: Partial<Conversation> & TExtra = {
+    getTurnTrust: () => merged.currentTurnTrustContext,
+    getTrustContext: () => merged.trustContext,
+    getTurnOrRestingTrust: () =>
+      merged.currentTurnTrustContext ?? merged.trustContext,
+    ...mock,
+  };
+  return merged as unknown as Conversation & TExtra;
 }
 
 /**

package/src/__tests__/injector-chain.test.ts

@@ -67,6 +67,7 @@ const { registerDefaultPluginInjectors } =
   await import("../plugins/defaults/index.js");
 import { eq } from "drizzle-orm";
 
+import type { InterfaceId } from "../channels/types.js";
 import {
   clearConversations,
   setConversation,
@@ -86,6 +87,7 @@ import type { Message } from "../providers/types.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { SubagentState } from "../subagent/types.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block
 // from the persisted message rows, so the schema must exist for Slack-channel
@@ -153,26 +155,30 @@ function seedWorkspaceContext(
   text: string,
   currentTurnTemporalSnapshot?: {
     clientTimezone: string | null;
+    timeSinceLastMessage: string | null;
   },
-  interfaceName?: string,
+  interfaceName?: InterfaceId,
 ): void {
-  setConversation(TEST_CONVERSATION_ID, {
-    conversationId: TEST_CONVERSATION_ID,
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: text,
-    workspaceTopLevelDirty: false,
-    currentTurnTemporalSnapshot,
-    currentTurnInterfaceContext: interfaceName
-      ? {
-          userMessageInterface: interfaceName,
-          assistantMessageInterface: interfaceName,
-        }
-      : undefined,
-    // Mirrors Conversation.getSubagentChildren: the `<active_subagents>` block
-    // is sourced from the live conversation, which delegates to the manager.
-    getSubagentChildren: () =>
-      getSubagentManager().getChildrenOf(TEST_CONVERSATION_ID),
-  } as never);
+  setConversation(
+    TEST_CONVERSATION_ID,
+    asConversation({
+      conversationId: TEST_CONVERSATION_ID,
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: text,
+      workspaceTopLevelDirty: false,
+      currentTurnTemporalSnapshot,
+      currentTurnInterfaceContext: interfaceName
+        ? {
+            userMessageInterface: interfaceName,
+            assistantMessageInterface: interfaceName,
+          }
+        : undefined,
+      // Mirrors Conversation.getSubagentChildren: the `<active_subagents>` block
+      // is sourced from the live conversation, which delegates to the manager.
+      getSubagentChildren: () =>
+        getSubagentManager().getChildrenOf(TEST_CONVERSATION_ID),
+    }),
+  );
 }
 
 // `applyRuntimeInjections` gates the `<turn_context>` block on the live
@@ -181,13 +187,19 @@ function seedWorkspaceContext(
 // fall back to the runtime-assembly fallback conversation, so seed the snapshot
 // there.
 function seedFallbackTemporalSnapshot(): void {
-  setConversation("runtime-assembly-fallback", {
-    conversationId: "runtime-assembly-fallback",
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: "",
-    workspaceTopLevelDirty: false,
-    currentTurnTemporalSnapshot: { clientTimezone: null },
-  } as never);
+  setConversation(
+    "runtime-assembly-fallback",
+    asConversation({
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      currentTurnTemporalSnapshot: {
+        clientTimezone: null,
+        timeSinceLastMessage: null,
+      },
+    }),
+  );
 }
 
 // Persist Slack-channel rows for the turn conversation so
@@ -484,7 +496,11 @@ describe("injector chain", () => {
     seedSubagentChild(TEST_CONVERSATION_ID, subagentChild);
     const subagentBlock = buildSubagentStatusBlock([subagentChild])!;
 
-    seedWorkspaceContext(workspaceText, { clientTimezone: null }, "macos");
+    seedWorkspaceContext(
+      workspaceText,
+      { clientTimezone: null, timeSinceLastMessage: null },
+      "macos",
+    );
     const result = await applyRuntimeInjections(runMessages, {
       ...makeTurnContext(),
     });
@@ -562,20 +578,23 @@ describe("injector chain", () => {
         createdAt: 1700000005_000,
       },
     ]);
-    setConversation(TEST_CONVERSATION_ID, {
-      conversationId: TEST_CONVERSATION_ID,
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      trustContext: { trustClass: "guardian" },
-      channelCapabilities: {
-        channel: "slack",
-        dashboardCapable: false,
-        supportsDynamicUi: false,
-        supportsVoiceInput: false,
-        chatType: "channel",
-      },
-    } as never);
+    setConversation(
+      TEST_CONVERSATION_ID,
+      asConversation({
+        conversationId: TEST_CONVERSATION_ID,
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
+        channelCapabilities: {
+          channel: "slack",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "channel",
+        },
+      }),
+    );
     const result = await applyRuntimeInjections(originalRun, {
       ...makeTurnContext(),
     });
@@ -614,7 +633,10 @@ describe("injector chain", () => {
       timestamp: FIXED_TURN_TIMESTAMP,
       interfaceName: "web",
     });
-    seedWorkspaceContext("", { clientTimezone: null });
+    seedWorkspaceContext("", {
+      clientTimezone: null,
+      timeSinceLastMessage: null,
+    });
     seedSubagentChild(
       TEST_CONVERSATION_ID,
       makeSubagentState("sub-1", "worker", "running"),

package/src/__tests__/injector-disk-pressure.test.ts

@@ -14,6 +14,7 @@ mock.module("../daemon/date-context.js", () => ({
   formatTurnTimestamp: () => FIXED_TURN_TIMESTAMP,
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   clearConversations,
   setConversation,
@@ -39,6 +40,7 @@ import {
 } from "../plugins/defaults/workspace/injectors.js";
 import type { Injector, TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block
 // from the persisted message rows, so the schema must exist for Slack-channel
@@ -90,38 +92,23 @@ const diskPressureInjector = findInjector("disk-pressure-warning");
 // turn can exercise both; the seed helpers mutate and re-register the same
 // instance. An empty (non-dirty) workspace cache resolves to no block, so
 // disk-pressure-only tests don't trigger a directory scan.
-let liveConversation: {
-  conversationId: string;
-  workingDir: string;
-  workspaceTopLevelContext: string | null;
-  workspaceTopLevelDirty: boolean;
-  diskPressureCleanupModeActive: boolean;
-  channelCapabilities?: ChannelCapabilities;
-  trustContext?: { trustClass: string };
-  currentTurnTemporalSnapshot?: {
-    clientTimezone: string | null;
-  };
-  currentTurnInterfaceContext?: {
-    userMessageInterface: string;
-    assistantMessageInterface: string;
-  };
-};
+let liveConversation: Conversation;
 
 function resetLiveConversation(): void {
-  liveConversation = {
+  liveConversation = asConversation({
     conversationId: TEST_CONVERSATION_ID,
     workingDir: "/workspace",
     workspaceTopLevelContext: "",
     workspaceTopLevelDirty: false,
     diskPressureCleanupModeActive: false,
-    trustContext: { trustClass: "guardian" },
+    trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
     // The unified-turn-context injector sources the interface label from the
     // live conversation's turn interface context; match the expected blocks.
     currentTurnInterfaceContext: {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     },
-  };
+  });
 }
 
 // `applyRuntimeInjections` gates the `<turn_context>` block on the live
@@ -130,24 +117,25 @@ function resetLiveConversation(): void {
 function seedTemporalSnapshot(): void {
   liveConversation.currentTurnTemporalSnapshot = {
     clientTimezone: null,
+    timeSinceLastMessage: null,
   };
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedChannelCapabilities(caps: ChannelCapabilities): void {
   liveConversation.channelCapabilities = caps;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedDiskPressure(cleanupModeActive: boolean): void {
   liveConversation.diskPressureCleanupModeActive = cleanupModeActive;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedWorkspaceContext(text: string): void {
   liveConversation.workspaceTopLevelContext = text;
   liveConversation.workspaceTopLevelDirty = false;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 // Persist Slack-channel rows for the turn conversation so

package/src/__tests__/llm-context-resolution.test.ts

@@ -1,4 +1,21 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+// Entry-name providers resolve context limits through their row's kind, so
+// the tests control the row store directly. A dangling label (no row) falls
+// back to the model's catalog owner.
+const connectionRows = new Map<string, { name: string; provider: string }>([
+  ["openai-work", { name: "openai-work", provider: "openai" }],
+  ["my-endpoint", { name: "my-endpoint", provider: "openai-compatible" }],
+]);
+mock.module("../persistence/db-connection.js", () => ({
+  getDb: () => ({}),
+}));
+mock.module("../providers/inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) =>
+    connectionRows.get(name) ?? null,
+  listConnections: () => [],
+  canonicalVellumConnection: () => null,
+}));
 
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
 import { LLMSchema } from "../config/schemas/llm.js";
@@ -131,6 +148,61 @@ describe("resolveEffectiveContextWindow", () => {
     expect(resolved.modelMaxInputTokens).toBe(1050000);
   });
 
+  test("an entry of a catalog kind resolves the model's own context limits", () => {
+    // The entries collapse stores connection names in the provider field;
+    // the row's kind carries the model's limits, so an entry label must not
+    // fall back to the 200k default when its kind serves the model.
+    const llm = LLMSchema.parse({
+      profiles: {
+        work: { provider: "openai-work", model: "gpt-5.5" },
+      },
+      activeProfile: "work",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+    expect(resolved.maxOutputTokens).toBeDefined();
+  });
+
+  test("a custom-endpoint entry keeps the conservative default for a catalog-colliding model id", () => {
+    // An openai-compatible endpoint's "gpt-5.5" is not OpenAI's; inheriting
+    // the built-in 1.05M limit would let oversized requests through.
+    const llm = LLMSchema.parse({
+      profiles: {
+        custom: { provider: "my-endpoint", model: "gpt-5.5" },
+      },
+      activeProfile: "custom",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(200000);
+    expect(resolved.maxOutputTokens).toBeUndefined();
+  });
+
+  test("a label with no row falls back to the model's catalog owner", () => {
+    const llm = LLMSchema.parse({
+      profiles: {
+        gone: { provider: "deleted-entry", model: "gpt-5.5" },
+      },
+      activeProfile: "gone",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+  });
+
   test("unknown catalog model falls back safely to the default 200k cap", () => {
     const llm = LLMSchema.parse({
       callSites: {