@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/__tests__/cli-logger-boundary-guard.test.ts

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { Glob } from "bun";
+
+/**
+ * Guard test for the CLI-logger boundary.
+ *
+ * `src/cli/logger.ts` is the plain-stdout writer for short-lived `assistant …`
+ * invocations. It has no level filtering and no log-file routing, so a
+ * daemon-side module that reaches for it writes debug output straight to a
+ * stdout the daemon may not own. When the daemon runs detached and its
+ * spawning parent has closed the read end of the stdout pipe, those writes
+ * fail with `EPIPE` and take the process down through the fatal-error handler.
+ *
+ * Daemon and shared modules use `getLogger()` from `util/logger.js`, which
+ * routes to the rotating log file and skips stdout entirely when stdout is not
+ * a TTY.
+ *
+ * `no-restricted-imports` in `eslint.config.mjs` bans this too, but matches on
+ * the import specifier. This guard resolves each relative import to a path, so
+ * it holds regardless of how the specifier is spelled.
+ */
+
+/** Tests run from `assistant/`. */
+const ASSISTANT_ROOT = process.cwd();
+const CLI_LOGGER_PATH = resolve(ASSISTANT_ROOT, "src/cli/logger.ts");
+
+/** Modules allowed to import the CLI logger: the CLI itself, and tests. */
+function isExempt(relPath: string): boolean {
+  return (
+    relPath.startsWith("src/cli/") ||
+    relPath.includes("/__tests__/") ||
+    relPath.endsWith(".test.ts")
+  );
+}
+
+function findCliLoggerImporters(): string[] {
+  const pattern = /\b(?:from|import)\s*\(?\s*["'](\.[^"']*logger\.js)["']/g;
+  const violations = new Set<string>();
+
+  for (const relPath of new Glob("src/**/*.ts").scanSync({
+    cwd: ASSISTANT_ROOT,
+  })) {
+    if (isExempt(relPath)) {
+      continue;
+    }
+    const filePath = join(ASSISTANT_ROOT, relPath);
+    for (const match of readFileSync(filePath, "utf-8").matchAll(pattern)) {
+      // Imports carry the compiled `.js` extension; sources are `.ts`.
+      const resolved = resolve(
+        dirname(filePath),
+        match[1]!.replace(/\.js$/, ".ts"),
+      );
+      if (resolved === CLI_LOGGER_PATH) {
+        violations.add(relPath);
+        break;
+      }
+    }
+  }
+  return Array.from(violations).sort();
+}
+
+describe("CLI logger boundary", () => {
+  test("no production module outside src/cli/ imports cli/logger", () => {
+    expect(findCliLoggerImporters()).toEqual([]);
+  });
+
+  test("the guard resolves the CLI logger it is guarding", () => {
+    // A typo in CLI_LOGGER_PATH would make the guard above vacuously pass.
+    expect(readFileSync(CLI_LOGGER_PATH, "utf-8")).toContain("getCliLogger");
+  });
+
+  test("pinned-tabs logs through the daemon logger", () => {
+    // The incident site: pinned-tab mutations run inside daemon host-browser
+    // request handling, on every tab pin, select, close, and invalidation.
+    const source = readFileSync(
+      join(ASSISTANT_ROOT, "src/tools/browser/pinned-tabs.ts"),
+      "utf-8",
+    );
+
+    expect(source).toContain('from "../../util/logger.js"');
+    expect(source).toContain('getLogger("pinned-tabs")');
+    expect(source).not.toContain("cli/logger");
+  });
+});

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

@@ -7,6 +7,10 @@
  * turn. The `context_compacted` event is the single source of truth for the
  * indicator — the paired `usage_update` intentionally omits
  * `contextWindowTokens` to avoid a redundant SwiftUI invalidation.
+ *
+ * Also covers the `context_window_usage` push, which carries the provider
+ * tokenizer's post-compaction count so the web indicator matches the numbers
+ * on the `/compact` result card.
  */
 import { describe, expect, mock, test } from "bun:test";
 
@@ -218,7 +222,8 @@ import { Conversation } from "../daemon/conversation.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeProvider() {
+function makeProvider(counts?: number[]) {
+  const pending = counts ? [...counts] : null;
   return {
     name: "mock-provider",
     async sendMessage(): Promise<ProviderResponse> {
@@ -229,16 +234,20 @@ function makeProvider() {
         stopReason: "end_turn",
       };
     },
+    // Present only when the test supplies counts, so the other cases keep
+    // exercising the local-estimate fallback.
+    ...(pending ? { countInputTokens: async () => pending.shift() ?? 0 } : {}),
   };
 }
 
 function makeConversation(
   collected: AssistantEvent[],
   id = "conv-compact-events",
+  counts?: number[],
 ): Conversation {
   return new Conversation(
     id,
-    makeProvider(),
+    makeProvider(counts),
     "system prompt",
     (msg) => {
       collected.push(msg);
@@ -383,6 +392,134 @@ describe("forceCompact event emission", () => {
   });
 });
 
+describe("forceCompact context-window usage push", () => {
+  test("pushes the post-compaction tokenizer count the result card reports", async () => {
+    const collected: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: true,
+      // Estimate-based figures the compaction pipeline records internally.
+      // The user-facing numbers come from the provider tokenizer instead.
+      previousEstimatedInputTokens: 43_000,
+      estimatedInputTokens: 12_000,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 10,
+      compactedPersistedMessages: 5,
+      summaryCalls: 1,
+      summaryInputTokens: 500,
+      summaryOutputTokens: 200,
+      summaryModel: "test-model",
+      summaryText: "summary text",
+    };
+
+    const conversation = makeConversation(
+      collected,
+      "conv-compact-usage",
+      [56_000, 18_000],
+    );
+    const result = await conversation.forceCompact();
+
+    expect(result.previousEstimatedInputTokens).toBe(56_000);
+    expect(result.estimatedInputTokens).toBe(18_000);
+
+    const usage = collected.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    const usageEvent = usage[0] as Extract<
+      AssistantEvent,
+      { type: "context_window_usage" }
+    >;
+    expect(usageEvent.conversationId).toBe("conv-compact-usage");
+    // Same figures the `/compact` card renders, so the indicator and the card
+    // cannot disagree.
+    expect(usageEvent.tokens).toBe(result.estimatedInputTokens);
+    expect(usageEvent.maxTokens).toBe(200_000);
+  });
+
+  test("pushes to the caller's sink when the conversation's own sender is dead", async () => {
+    // A `/compact` draining behind an interactive turn: `process-message.ts`
+    // resets `sendToClient` to a no-op in its `finally`, while the queued item
+    // still carries the live sink its result card streams on. The push has to
+    // follow the card, not the dead sender.
+    const stranded: AssistantEvent[] = [];
+    const cardSink: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: true,
+      previousEstimatedInputTokens: 43_000,
+      estimatedInputTokens: 12_000,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 10,
+      compactedPersistedMessages: 5,
+      summaryCalls: 1,
+      summaryInputTokens: 500,
+      summaryOutputTokens: 200,
+      summaryModel: "test-model",
+      summaryText: "summary text",
+    };
+
+    const conversation = makeConversation(
+      stranded,
+      "conv-compact-dead-sender",
+      [56_000, 18_000],
+    );
+    conversation.updateClient(() => {}, true);
+
+    const result = await conversation.forceCompact((msg) => cardSink.push(msg));
+
+    const usage = cardSink.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    expect(
+      (usage[0] as Extract<AssistantEvent, { type: "context_window_usage" }>)
+        .tokens,
+    ).toBe(result.estimatedInputTokens);
+    expect(
+      stranded.filter((m) => m.type === "context_window_usage").length,
+    ).toBe(0);
+  });
+
+  test("pushes the current count when there was nothing to compact", async () => {
+    const collected: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: false,
+      previousEstimatedInputTokens: 0,
+      estimatedInputTokens: 0,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 0,
+      compactedPersistedMessages: 0,
+      summaryCalls: 0,
+      summaryInputTokens: 0,
+      summaryOutputTokens: 0,
+      summaryModel: "",
+      summaryText: "",
+    };
+
+    const conversation = makeConversation(
+      collected,
+      "conv-compact-usage-noop",
+      // A no-op re-counts nothing, so the single count stands as before and
+      // after.
+      [56_000],
+    );
+    const result = await conversation.forceCompact();
+
+    expect(result.previousEstimatedInputTokens).toBe(56_000);
+    expect(result.estimatedInputTokens).toBe(56_000);
+
+    const usage = collected.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    const usageEvent = usage[0] as Extract<
+      AssistantEvent,
+      { type: "context_window_usage" }
+    >;
+    expect(usageEvent.tokens).toBe(56_000);
+    expect(usageEvent.maxTokens).toBe(200_000);
+  });
+});
+
 describe("maybeCompact gate sizing", () => {
   test("default sizing resolves mainAgent's window; wake sizing resolves the wake's call-site window", async () => {
     // The auto-threshold gate derives its trip point from the

package/src/__tests__/config-loader-backfill.test.ts

@@ -864,7 +864,7 @@ describe("loadConfig startup behavior", () => {
     expect(effective["quality-optimized"]?.provider).toBe("openai");
     expect(effective["quality-optimized"]?.model).toBe("gpt-5.4");
     expect(effective["cost-optimized"]?.provider).toBe("openai");
-    expect(effective["cost-optimized"]?.model).toBe("gpt-5.6-luna");
+    expect(effective["cost-optimized"]?.model).toBe("gpt-5.4-nano");
   });
 
   test("off-platform hatch with a provider outside the named matrix columns resolves through the shared BYOK templates", () => {
@@ -1471,7 +1471,7 @@ describe("seedInferenceProfiles BYOK-mode default profiles", () => {
     );
     expect(effective.balanced?.label).toBe("Balanced");
     expect(effective["quality-optimized"]?.label).toBe("Quality");
-    expect(effective["cost-optimized"]?.label).toBe("Speed");
+    expect(effective["cost-optimized"]?.label).toBe("Cost");
     expect("status" in (effective.balanced ?? {})).toBe(false);
     expect("status" in (effective["quality-optimized"] ?? {})).toBe(false);
     expect("status" in (effective["cost-optimized"] ?? {})).toBe(false);
@@ -1741,7 +1741,39 @@ describe("seedInferenceProfiles BYOK-mode default profiles", () => {
     const effective = getEffectiveProfiles(raw.llm.profiles);
     expect(effective.balanced?.label).toBe("Balanced");
     expect(effective["quality-optimized"]?.label).toBe("Quality");
-    expect(effective["cost-optimized"]?.label).toBe("Speed");
+    expect(effective["cost-optimized"]?.label).toBe("Cost");
+  });
+
+  test("a managed key missing from profileOrder lands beside its siblings", () => {
+    // An install that predates a newly shipped managed profile, with a custom
+    // profile already in its order. The new key belongs with the other
+    // managed profiles, not after whatever the user has arranged below them.
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        profiles: {
+          "my-custom": { source: "user", provider: "anthropic", model: "x" },
+        },
+        profileOrder: [
+          "balanced",
+          "quality-optimized",
+          "cost-optimized",
+          "my-custom",
+        ],
+        activeProfile: "balanced",
+      },
+    });
+
+    mergeDefaultConfigAndSeedInferenceProfiles();
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+    expect(raw.llm.profileOrder).toEqual([
+      "balanced",
+      "quality-optimized",
+      "cost-optimized",
+      "latency-optimized",
+      "my-custom",
+    ]);
   });
 
   test("boot leaves legacy bare labels on managed entries untouched", () => {

package/src/__tests__/config-schema.test.ts

@@ -747,6 +747,7 @@ describe("AssistantConfigSchema", () => {
       failureBackoffBaseMs: 2000,
       failureBackoffMaxMs: 60000,
       maxFileSizeBytes: 256000,
+      historyCompaction: { enabled: true },
       interactiveGitTimeoutMs: 10000,
       enrichmentQueueSize: 50,
       enrichmentConcurrency: 1,

package/src/__tests__/conversation-agent-loop-fatal-cleanup.test.ts

@@ -215,3 +215,33 @@ describe("runAgentLoopImpl fatal-failure cleanup (ATL-1009)", () => {
     expect(drainQueue).toHaveBeenCalledWith("loop_complete");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Turn-scoped view state
+//
+// The app the client has on screen rides in on a message's transport. Nothing
+// tells the daemon when the user closes it, so leaving the value on the
+// conversation would let a later turn with no fresh client transport (a
+// scheduled wake, a background follow-up) assert the user is looking at an app
+// they closed. This suite reuses the loop harness above because the clear
+// lives in the loop's per-turn teardown.
+// ---------------------------------------------------------------------------
+
+describe("runAgentLoopImpl per-turn view state", () => {
+  test("clears the reported visible app at turn end so a later turn cannot inherit it", async () => {
+    const events: AssistantEvent[] = [];
+    const ctx = makeCtx({
+      visibleAppId: "app-on-screen",
+      commitTurnChanges: mock(
+        async () => {},
+      ) as unknown as Context["commitTurnChanges"],
+    });
+
+    await runAgentLoopImpl(ctx, "background task", "msg-visible-app", (event) =>
+      events.push(event),
+    );
+
+    expect(ctx.visibleAppId).toBeUndefined();
+    expect(ctx.currentTurnVisibleAppId).toBeUndefined();
+  });
+});

package/src/__tests__/conversation-agent-loop.test.ts

@@ -349,6 +349,7 @@ mock.module("../persistence/conversation-crud.js", () => ({
   finalizeMessageContent: finalizeMessageContentMock,
   recordConversationPersistedSeq: () => {},
   getConversationPersistedSeq: () => null,
+  PROVIDER_ERROR_MESSAGE_KIND: "provider_error",
   // The real schema is a Zod object; tests don't exercise validation,
   // so a passthrough is sufficient — the production code at
   // `handleMessageComplete` only branches on `success` and reads two
@@ -379,6 +380,11 @@ mock.module("../runtime/sync/sync-publisher.js", () => ({
   publishSyncInvalidation: publishSyncInvalidationMock,
 }));
 
+const emitAssistantReplyNotificationMock = mock(async () => {});
+mock.module("../notifications/assistant-reply-producer.js", () => ({
+  emitAssistantReplyNotification: emitAssistantReplyNotificationMock,
+}));
+
 afterAll(() => {
   mock.module(
     "../persistence/conversation-crud.js",
@@ -895,6 +901,7 @@ beforeEach(() => {
   setAgentLoopExitReasonOnLatestLogMock.mockClear();
   syncMessageToDiskMock.mockClear();
   rebuildConversationDiskViewFromDbStateMock.mockClear();
+  emitAssistantReplyNotificationMock.mockClear();
   updateMessageMetadataMock.mockClear();
   updateMessageMetadataMock.mockImplementation(() => {});
   updateConversationSlackContextWatermarkMock.mockClear();
@@ -2227,6 +2234,49 @@ describe("session-agent-loop", () => {
       expect(backfillCall[1]).toBe("mock-msg-id");
     });
 
+    test("stamps provider-error metadata onto the persisted synthetic assistant row", async () => {
+      mockConversationErrorClassification = {
+        code: "PROVIDER_BILLING",
+        userMessage:
+          "You're out of credits. Add credits in Settings → Billing to continue.",
+        retryable: false,
+        errorCategory: "credits_exhausted",
+      };
+
+      const ctx = makeCtx({
+        loopProvider: {
+          name: "mock-provider",
+          async sendMessage() {
+            throw new Error("Payment Required");
+          },
+        } as unknown as Provider,
+      });
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(addMessageMock).toHaveBeenCalledTimes(1);
+      const addCall = addMessageMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        { metadata?: Record<string, unknown> },
+      ];
+      expect(addCall[1]).toBe("assistant");
+      // The persisted row swaps the context-neutral classification copy for
+      // assistant-voice wording, since this turn truly ends with no reply.
+      const persistedBlocks = JSON.parse(addCall[2]) as Array<{
+        type: string;
+        text: string;
+      }>;
+      expect(persistedBlocks[0]?.text).toBe(
+        "I couldn't reply because you ran out of credits. Add credits in Settings → Billing and we can pick up where we left off.",
+      );
+      expect(addCall[3]?.metadata).toMatchObject({
+        messageKind: "provider_error",
+        providerErrorCode: "PROVIDER_BILLING",
+        providerErrorCategory: "credits_exhausted",
+      });
+    });
+
     test("does not persist managed credential refresh failures as assistant text", async () => {
       mockConversationErrorClassification = {
         code: "MANAGED_KEY_INVALID",
@@ -2269,6 +2319,120 @@ describe("session-agent-loop", () => {
       ];
       expect(deleteCall[0]).toBe("msg-reserve");
     });
+
+    test("does not push the synthetic error row as a reply notification", async () => {
+      // The synthetic row carries the provider's error text. It reaches the
+      // `message_complete` branch like any other turn, so without the
+      // provider-error guard the tail would send that text to the lock screen
+      // as if it were the assistant's reply.
+      const ctx = makeCtx({
+        loopProvider: {
+          name: "mock-provider",
+          async sendMessage() {
+            throw new Error("upstream 500");
+          },
+        } as unknown as Provider,
+      });
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(addMessageMock).toHaveBeenCalled();
+      expect(emitAssistantReplyNotificationMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("assistant-reply notification wiring", () => {
+    test("a completed turn notifies with the row that opened it", async () => {
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const ctx = makeCtx({
+        providerResponses: [textResponse("here you go")],
+      });
+      await runAgentLoopImpl(ctx, "hi", "msg-user-7", () => {});
+
+      expect(emitAssistantReplyNotificationMock).toHaveBeenCalledTimes(1);
+      const notifyCall = emitAssistantReplyNotificationMock.mock
+        .calls[0] as unknown as [
+        { conversationId: string; userMessageId: string | undefined },
+      ];
+      expect(notifyCall[0]).toMatchObject({
+        conversationId: "test-conv",
+        userMessageId: "msg-user-7",
+      });
+    });
+
+    test("a caller-supplied notify row overrides the turn's user message id", async () => {
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const ctx = makeCtx({
+        providerResponses: [textResponse("here you go")],
+      });
+      await runAgentLoopImpl(ctx, "hi", "msg-user-tail", () => {}, {
+        notifyUserMessageId: "msg-user-prompt",
+      });
+
+      expect(emitAssistantReplyNotificationMock).toHaveBeenCalledTimes(1);
+      const notifyCall = emitAssistantReplyNotificationMock.mock
+        .calls[0] as unknown as [{ userMessageId: string | undefined }];
+      expect(notifyCall[0].userMessageId).toBe("msg-user-prompt");
+    });
+
+    test("threads the app-only delivery marker to the producer", async () => {
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const ctx = makeCtx({
+        providerResponses: [textResponse("here you go")],
+      });
+      await runAgentLoopImpl(ctx, "hi", "msg-user-8", () => {}, {
+        replyDeliveredInAppOnly: true,
+      });
+
+      expect(emitAssistantReplyNotificationMock).toHaveBeenCalledTimes(1);
+      const notifyCall = emitAssistantReplyNotificationMock.mock
+        .calls[0] as unknown as [{ replyDeliveredInAppOnly?: boolean }];
+      expect(notifyCall[0].replyDeliveredInAppOnly).toBe(true);
+    });
+
+    test("omits the app-only delivery marker for an ordinary turn", async () => {
+      mockMessageById = {
+        id: "msg-reserve",
+        conversationId: "test-conv",
+        createdAt: 1234567,
+        role: "assistant",
+        content: "[]",
+        metadata: null,
+      };
+
+      const ctx = makeCtx({
+        providerResponses: [textResponse("here you go")],
+      });
+      await runAgentLoopImpl(ctx, "hi", "msg-user-9", () => {});
+
+      expect(emitAssistantReplyNotificationMock).toHaveBeenCalledTimes(1);
+      const notifyCall = emitAssistantReplyNotificationMock.mock
+        .calls[0] as unknown as [Record<string, unknown>];
+      expect(notifyCall[0]).not.toHaveProperty("replyDeliveredInAppOnly");
+    });
   });
 
   describe("B3 pre-allocation: indexing + cleanup", () => {
@@ -2858,12 +3022,20 @@ describe("session-agent-loop", () => {
       }));
 
       // GIVEN a real loop whose provider streams a delta — landing a debounced
-      // partial flush on the reserved row — then rejects, so the loop emits
-      // `provider_error` and `error` and exits with no `message_complete`.
+      // partial flush on the reserved row — then rejects. The loop resumes a
+      // call that died after it had started streaming, so the second attempt
+      // is scripted to fail before streaming anything: that keeps exactly one
+      // row carrying partial content, and the turn then exits via
+      // `provider_error` with no `message_complete`.
+      let attempt = 0;
       const ctx = makeCtx({
         loopProvider: {
           name: "mock-provider",
           async sendMessage(_messages, options) {
+            attempt++;
+            if (attempt > 1) {
+              throw new Error("upstream 500");
+            }
             options?.onEvent?.({ type: "text_delta", text: "hello world" });
             await new Promise((resolve) => setTimeout(resolve, 1100));
             throw new Error("upstream 500");
@@ -2887,11 +3059,12 @@ describe("session-agent-loop", () => {
         .split("\n");
       expect(orphanLines).toHaveLength(1);
       expect(updateMessageContentMock).toHaveBeenCalledTimes(0);
-      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
-      const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
-        string,
-      ];
-      expect(deleteCall[0]).toBe("msg-orphan-with-partial");
+      // Scoped to the row under test: the resumed attempt reserves a row of
+      // its own, which its own cleanup deletes.
+      const deletedIds = deleteMessageByIdMock.mock.calls.map(
+        (call) => (call as unknown as [string])[0],
+      );
+      expect(deletedIds).toContain("msg-orphan-with-partial");
     });
   });