@vellumai/assistant 0.12.3-staging.2 → 0.12.4-staging.1

package/src/runtime/__tests__/agent-wake-archived-gate.test.ts

@@ -0,0 +1,90 @@
+/**
+ * The `sidebar-done` gate on the wake's archived-conversation rejection.
+ *
+ * `defaultResolveTarget` is module-private, so it is exercised through
+ * `wakeAgentForOpportunity()` called without explicit deps. The hydrate step
+ * after the archived check is stubbed to throw, which the resolver catches
+ * and reports as `not_found` — a flag-on result of `not_found` therefore
+ * proves the wake got PAST the archived check and tried to hydrate, while a
+ * result of `archived` proves it did not.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let sidebarDoneEnabled = false;
+mock.module("../../config/sidebar-done-gate.js", () => ({
+  SIDEBAR_DONE_FLAG_KEY: "sidebar-done",
+  isSidebarDoneEnabled: () => sidebarDoneEnabled,
+}));
+
+const ARCHIVED_CONVERSATION_ID = "conv-archived-wake";
+
+const getConversationMock = mock((id: string) =>
+  id === ARCHIVED_CONVERSATION_ID
+    ? { id, archivedAt: 1_700_000_000_000 }
+    : undefined,
+);
+const actualCrud = await import("../../persistence/conversation-crud.js");
+mock.module("../../persistence/conversation-crud.js", () => ({
+  ...actualCrud,
+  getConversation: getConversationMock,
+}));
+
+const getOrCreateConversationMock = mock(async () => {
+  throw new Error("hydrate stub");
+});
+const actualStore = await import("../../daemon/conversation-store.js");
+mock.module("../../daemon/conversation-store.js", () => ({
+  ...actualStore,
+  getOrCreateConversation: getOrCreateConversationMock,
+}));
+
+import { wakeAgentForOpportunity } from "../agent-wake.js";
+
+describe("agent-wake archived conversations under sidebar-done", () => {
+  beforeEach(() => {
+    getConversationMock.mockClear();
+    getOrCreateConversationMock.mockClear();
+  });
+
+  test("rejects the wake with reason archived when the flag is off", async () => {
+    sidebarDoneEnabled = false;
+
+    const result = await wakeAgentForOpportunity({
+      conversationId: ARCHIVED_CONVERSATION_ID,
+      hint: "scheduled run",
+      source: "schedule",
+    });
+
+    expect(result.invoked).toBe(false);
+    expect(result.reason).toBe("archived");
+    expect(getOrCreateConversationMock).not.toHaveBeenCalled();
+  });
+
+  test("proceeds past the archived check when the flag is on", async () => {
+    sidebarDoneEnabled = true;
+
+    const result = await wakeAgentForOpportunity({
+      conversationId: ARCHIVED_CONVERSATION_ID,
+      hint: "scheduled run",
+      source: "schedule",
+    });
+
+    expect(result.reason).not.toBe("archived");
+    expect(getOrCreateConversationMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("still reports not_found for a conversation that does not exist", async () => {
+    sidebarDoneEnabled = true;
+
+    const result = await wakeAgentForOpportunity({
+      conversationId: "conv-missing",
+      hint: "scheduled run",
+      source: "schedule",
+    });
+
+    expect(result.invoked).toBe(false);
+    expect(result.reason).toBe("not_found");
+    expect(getOrCreateConversationMock).not.toHaveBeenCalled();
+  });
+});

package/src/runtime/__tests__/question-resolution.test.ts

@@ -73,6 +73,38 @@ describe("resolvePendingQuestion", () => {
     });
   });
 
+  test("chat_reply: the typed text answers the first question, the rest stay unanswered", () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion(
+      "req-1",
+      [
+        { id: "q1", options: ["a"] },
+        { id: "q2", options: ["b"] },
+      ],
+      (v) => resolved.push(v as QuestionPromptResult),
+    );
+
+    const outcome = resolvePendingQuestion("req-1", {
+      kind: "chat_reply",
+      text: "tuesday, and keep it short",
+    });
+
+    expect(outcome.status).toBe("resolved");
+    expect(resolved[0]).toEqual({
+      overall: "completed",
+      entries: [
+        {
+          questionId: "q1",
+          decision: "free_text",
+          text: "tuesday, and keep it short",
+        },
+        { questionId: "q2", decision: "skipped" },
+      ],
+      answeredInChat: true,
+    });
+    expect(pendingInteractions.get("req-1")).toBeUndefined();
+  });
+
   test("not_found: unknown or wrong-kind requestId leaves nothing resolved", () => {
     expect(resolvePendingQuestion("missing", { kind: "close" })).toEqual({
       status: "not_found",

package/src/runtime/agent-wake.ts

@@ -84,6 +84,7 @@ import {
 } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import { isSidebarDoneEnabled } from "../config/sidebar-done-gate.js";
 import { conversationSupportsDynamicUi } from "../daemon/channel-ui-capability.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
@@ -506,7 +507,8 @@ export interface WakeDeps {
   /**
    * Resolve the live {@link Conversation} for a wake invocation.
    * Returns `null` if the conversation doesn't exist, `"archived"` if it
-   * exists but is archived, or the `Conversation` to proceed with the wake.
+   * exists but is archived and the `sidebar-done` gate is off, or the
+   * `Conversation` to proceed with the wake.
    *
    * Receives the full {@link WakeOptions} so the default resolver can
    * thread `trustContext` into `getOrCreateConversation`. Without that
@@ -546,7 +548,12 @@ async function defaultResolveTarget(
     if (!existing) {
       return null;
     }
-    if (existing.archivedAt != null) {
+    // Under the `sidebar-done` gate an archived conversation is one the user
+    // marked Done, not one they half-deleted: its schedules, channel threads
+    // and background tools keep working, and the first message the wake
+    // produces for the user brings the conversation back to the list
+    // (`resurfaceArchivedConversation`).
+    if (existing.archivedAt != null && !isSidebarDoneEnabled()) {
       log.info(
         { conversationId },
         "agent-wake: conversation is archived; rejecting wake",

package/src/runtime/auth/__tests__/middleware.test.ts

@@ -325,6 +325,144 @@ describe("authenticateRequest for /v1/host-browser-result", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Dev bypass covers only a request that supplied no Authorization header. A
+// bearer sent to a platform pod (the gateway's exchange token, or a trusted
+// contact's) is verified on its own terms.
+// ---------------------------------------------------------------------------
+
+describe("authenticateRequest with auth disabled and a bearer present", () => {
+  beforeEach(() => {
+    authDisabled = true;
+  });
+
+  test("uses the token's claims rather than the dev-bypass context", () => {
+    const token = mintValidToken({ sub: "actor:self:contact-principal" });
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.actorPrincipalId).toBe("contact-principal");
+      expect(result.context.policyEpoch).toBe(CURRENT_POLICY_EPOCH);
+    }
+  });
+
+  test("accepts the gateway's exchange token", () => {
+    const token = mintValidToken({
+      sub: "svc:gateway:self",
+      scope_profile: "gateway_service_v1",
+    });
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.principalType).toBe("svc_gateway");
+    }
+  });
+
+  test("accepts a gateway-audience token through the fallback", () => {
+    const token = mintValidToken({
+      aud: "vellum-gateway",
+      sub: "actor:self:local-client",
+    });
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.actorPrincipalId).toBe("local-client");
+      expect(result.context.assistantId).toBe(DAEMON_INTERNAL_ASSISTANT_ID);
+    }
+  });
+
+  test.each([
+    ["malformed", () => "not-a-token.xxxxxxxxxxxxx"],
+    [
+      "expired",
+      () => mintValidToken({ exp: Math.floor(Date.now() / 1000) - 100 }),
+    ],
+    [
+      "wrong-audience",
+      () => mintValidToken({ aud: "vellum-other" as TokenAudience }),
+    ],
+    ["unparseable-sub", () => mintValidToken({ sub: "garbage" })],
+  ])("refuses a %s token rather than falling back", (_label, build) => {
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${build()}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.response.status).toBe(401);
+    }
+  });
+
+  test("still returns the dev-bypass context when no bearer is sent", () => {
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.actorPrincipalId).toBe("dev-bypass");
+    }
+  });
+
+  test("verifies a lowercase bearer scheme rather than bypassing it", () => {
+    const token = mintValidToken({ sub: "actor:self:contact-principal" });
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `bearer ${token}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.actorPrincipalId).toBe("contact-principal");
+    }
+  });
+
+  test.each([
+    ["lowercase scheme with a bad token", "bearer not-a-jwt.xxxxxxxx"],
+    ["empty credential", "Bearer "],
+    ["non-bearer scheme", "Basic dXNlcjpwYXNz"],
+    ["an empty header value", ""],
+    ["a whitespace-only header value", "   "],
+  ])(
+    "refuses %s instead of granting the dev-bypass context",
+    (_label, header) => {
+      const req = new Request("http://localhost/v1/messages", {
+        method: "POST",
+        headers: { Authorization: header },
+      });
+
+      const result = authenticateRequest(req);
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.response.status).toBe(401);
+      }
+    },
+  );
+});
+
 // ---------------------------------------------------------------------------
 // oauth_proxy_v1 grants: the narrow bearer a third-party CLI presents to the
 // OAuth passthrough route. Accepted on either audience, and carrying nothing

package/src/runtime/auth/middleware.ts

@@ -17,9 +17,10 @@
  * Replaces both the legacy bearer shared-secret check and the
  * actor-token HMAC middleware with a single JWT verification path.
  *
- * When DISABLE_HTTP_AUTH is set (platform-managed deployments), JWT
- * verification is skipped and a synthetic AuthContext is constructed
- * so downstream code always has a typed context to consume.
+ * When DISABLE_HTTP_AUTH is set (platform-managed deployments), a request
+ * carrying no bearer gets a synthetic AuthContext so downstream code always
+ * has a typed context to consume. A request that carries one is verified
+ * normally, and a bad token is refused rather than falling back.
  */
 
 import { isHttpAuthDisabled } from "../../config/env.js";
@@ -73,17 +74,18 @@ function buildDevBypassContext(): AuthContext {
  * The caller should return the error Response directly to the client.
  */
 export function authenticateRequest(req: Request): AuthenticateResult {
-  // Dev bypass: skip JWT verification entirely
-  if (isHttpAuthDisabled()) {
-    return { ok: true, context: buildDevBypassContext() };
-  }
-
-  const path = new URL(req.url).pathname;
-
   const rawToken = extractBearerToken(req);
   if (!rawToken) {
+    // Dev bypass covers only a request that supplied no Authorization header
+    // at all. A header that is present but unusable (empty or whitespace-only
+    // value, a non-bearer scheme, a malformed credential) is refused rather
+    // than handed the guardian context. `has` rather than `get`: an empty
+    // value reads back as "" and would otherwise pass as absent.
+    if (isHttpAuthDisabled() && !req.headers.has("authorization")) {
+      return { ok: true, context: buildDevBypassContext() };
+    }
     log.warn(
-      { reason: "missing_token", path },
+      { reason: "missing_token", path: new URL(req.url).pathname },
       "Auth denied: missing Authorization header",
     );
     return {
@@ -100,6 +102,8 @@ export function authenticateRequest(req: Request): AuthenticateResult {
     };
   }
 
+  const path = new URL(req.url).pathname;
+
   // Verify the JWT — prefer vellum-daemon audience (gateway-proxied requests
   // and daemon-minted tokens), but also accept vellum-gateway audience for
   // direct local clients (macOS SettingsStore) that hold a guardian-issued JWT

package/src/runtime/middleware/auth.ts

@@ -156,8 +156,14 @@ export function isPrivateNetworkOrigin(req: Request): boolean {
 /**
  * Extract and validate a bearer token from the Authorization header.
  * Returns the token string if present, or null.
+ *
+ * The scheme is matched case-insensitively, per RFC 7235 and to match the
+ * gateway's own parsing. An empty credential returns null.
  */
 export function extractBearerToken(req: Request): string | null {
   const authHeader = req.headers.get("authorization");
-  return authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  if (!authHeader?.toLowerCase().startsWith("bearer ")) {
+    return null;
+  }
+  return authHeader.slice(7) || null;
 }

package/src/runtime/pending-interactions.ts

@@ -265,14 +265,14 @@ export function getByConversation(
  * /v1/host-transfer-result after completing the operation, get a 404, and the
  * proxy timer would fire with a spurious timeout error.
  *
- * `question` interactions are also skipped: a new message supersedes an open
- * ask_question by steering to it (see the enqueue path in
- * conversation-routes.ts), which aborts the parked turn and settles the
- * question via its abort signal. Clearing the entry here instead would drop it
- * without settling the prompt's Promise (questions carry no `rpcResolve`
- * fallback like secrets do) and would strip the steer of the entry it needs to
- * fire — which can co-occur with a confirmation, since one model response can
- * open both tools concurrently.
+ * `question` interactions are also skipped: a new message settles an open
+ * ask_question at the enqueue path (see `daemon/handlers/conversations.ts`),
+ * either by answering it with the typed text or by steering to the message,
+ * which aborts the parked turn and settles the question via its abort signal.
+ * Clearing the entry here instead would drop it without settling the prompt's
+ * Promise (questions carry no `rpcResolve` fallback like secrets do) and would
+ * strip both paths of the entry they need, which can co-occur with a
+ * confirmation since one model response can open both tools concurrently.
  */
 export function removeByConversation(
   conversationId: string,

package/src/runtime/question-resolution.ts

@@ -2,7 +2,7 @@
  * Shared resolution core for pending `ask_question` interactions.
  *
  * A pending `question` interaction (registered by {@link QuestionPrompter}) can
- * be resolved from two places:
+ * be resolved from three places:
  *
  *  - `POST /v1/question-response` — an app/web client submits the user's
  *    batched selection (see `routes/question-routes.ts`).
@@ -10,8 +10,11 @@
  *    or bare-text answer routes through the guardian reply router to the
  *    `pending_question` resolver, which builds the submission (see
  *    `approvals/guardian-request-resolvers.ts`).
+ *  - the enqueue path: a message typed into the chat while the card is open
+ *    answers the parked question as free text (see
+ *    `daemon/handlers/conversations.ts`).
  *
- * Both funnel through {@link resolvePendingQuestion} so the validate → consume
+ * All funnel through {@link resolvePendingQuestion} so the validate → consume
  * → `rpcResolve` sequence has a single implementation. The helper is
  * transport-agnostic: it returns a discriminated outcome rather than throwing
  * route errors, so each caller maps the outcome to its own surface (HTTP status
@@ -28,12 +31,20 @@ import {
 import * as pendingInteractions from "./pending-interactions.js";
 
 /**
- * How to resolve a pending question: a batched submission (one entry per
- * question) or a close (every question reported as `skipped`).
+ * How to resolve a pending question:
+ *
+ *  - `submit`: a batched submission, one entry per question.
+ *  - `close`: the card was dismissed; every question is reported as
+ *    `skipped`.
+ *  - `chat_reply`: the user typed a message into the chat while the card was
+ *    open. The text answers the first question as free text and the rest stay
+ *    `skipped`; the result is flagged so the tool tells the model where the
+ *    answer came from.
  */
 export type QuestionResolutionInput =
   | { kind: "submit"; submissions: QuestionBatchSubmission[] }
-  | { kind: "close" };
+  | { kind: "close" }
+  | { kind: "chat_reply"; text: string };
 
 /**
  * Outcome of {@link resolvePendingQuestion}.
@@ -57,9 +68,10 @@ export type QuestionResolutionOutcome =
   | { status: "invalid"; message: string };
 
 /**
- * Resolve a pending `question` interaction with a batched submission or a
- * close. Validation runs BEFORE the interaction is consumed, so an `invalid`
- * outcome leaves the pending prompt (and its timer) intact for a retry.
+ * Resolve a pending `question` interaction with a batched submission, a close,
+ * or a chat reply. Validation runs BEFORE the interaction is consumed, so an
+ * `invalid` outcome leaves the pending prompt (and its timer) intact for a
+ * retry.
  */
 export function resolvePendingQuestion(
   requestId: string,
@@ -81,6 +93,8 @@ export function resolvePendingQuestion(
         })),
         overall: "closed",
       };
+    } else if (input.kind === "chat_reply") {
+      result = buildChatReplyResult(input.text, interaction);
     } else {
       result = buildCompletedResult(input.submissions, interaction);
     }
@@ -136,6 +150,38 @@ function buildCompletedResult(
   return { entries, overall: "completed" };
 }
 
+/**
+ * Build the result for a chat reply: the typed text answers the first question
+ * as free text, every other question stays `skipped`.
+ *
+ * The daemon holds no partial per-question state (the card keeps the user's
+ * in-progress answers locally until the whole batch is posted), so the first
+ * question is by construction the first unanswered one. Which question the
+ * text really speaks to is the model's call, not the daemon's: the flag on the
+ * result tells it the answer came from the chat rather than the card, and it
+ * maps the reply onto the batch from there.
+ */
+function buildChatReplyResult(
+  text: string,
+  interaction: ReturnType<typeof pendingInteractions.get>,
+): QuestionPromptResult {
+  const { orderedIds } = readBatchMetadata(interaction);
+  if (orderedIds.length === 0) {
+    throw new QuestionBatchValidationError(
+      "No registered question ids for this batch",
+    );
+  }
+  return {
+    entries: orderedIds.map((id, index) =>
+      index === 0
+        ? { questionId: id, decision: "free_text" as const, text }
+        : { questionId: id, decision: "skipped" as const },
+    ),
+    overall: "completed",
+    answeredInChat: true,
+  };
+}
+
 /**
  * Pull the prompter-stashed batch bookkeeping off a pending interaction.
  * Returns empty defaults if the metadata is absent.

package/src/runtime/routes/__tests__/conversation-list-routes.test.ts

@@ -1302,3 +1302,149 @@ describe("GET /v1/conversations/sections", () => {
     expect(sections.some((s) => s.kind === "pinned")).toBe(false);
   });
 });
+
+describe("GET /v1/conversations, conversationType=all", () => {
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  function setLastMessageAt(id: string, at: number): void {
+    rawRun(
+      "test:setLastMessageAt",
+      "UPDATE conversations SET last_message_at = ? WHERE id = ?",
+      at,
+      id,
+    );
+  }
+
+  test("returns the standard listing and the background umbrella together", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "bg-1",
+      "foreground-1",
+      "sched-1",
+    ]);
+  });
+
+  test("with archiveStatus=all one page spans live and done rows of every type", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    seedArchived("archived-1");
+    const archivedBackground = createConversation({
+      title: "archived-bg",
+      conversationType: "background",
+    });
+    rawRun(
+      "test:archiveConversation",
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      archivedBackground.id,
+    );
+
+    const result = (await invoke({
+      conversationType: "all",
+      archiveStatus: "all",
+    })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "archived-1",
+      "archived-bg",
+      "bg-1",
+      "foreground-1",
+    ]);
+    expect(result.hasMore).toBe(false);
+  });
+
+  test("orders by last message time descending across the types it merges", async () => {
+    const oldest = createConversation("oldest-foreground");
+    const middle = createConversation({
+      title: "middle-background",
+      conversationType: "background",
+    });
+    const newest = createConversation("newest-foreground");
+    setLastMessageAt(oldest.id, 1000);
+    setLastMessageAt(middle.id, 2000);
+    setLastMessageAt(newest.id, 3000);
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual([
+      "newest-foreground",
+      "middle-background",
+      "oldest-foreground",
+    ]);
+  });
+
+  test("excludes legacy private rows and subagent runs", async () => {
+    createConversation("foreground-1");
+    const legacyPrivate = createConversation("legacy-private");
+    rawRun(
+      "test:legacyPrivateRow",
+      "UPDATE conversations SET conversation_type = 'private', group_id = 'system:background' WHERE id = ?",
+      legacyPrivate.id,
+    );
+    const subagent = createConversation({
+      title: "subagent-run",
+      conversationType: "background",
+    });
+    rawRun(
+      "test:subagentRun",
+      "UPDATE conversations SET source = 'subagent' WHERE id = ?",
+      subagent.id,
+    );
+
+    const result = (await invoke({ conversationType: "all" })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["foreground-1"]);
+  });
+
+  test("never appends pinned rows outside the page", async () => {
+    // Pinned injection is the compatibility shim for the default sidebar
+    // read. A whole-history page already contains the pinned row in recency
+    // order, so appending it would duplicate it and put hasMore out of step
+    // with the count.
+    const pinned = createConversation("pinned-1");
+    rawRun(
+      "test:pinConversation",
+      "UPDATE conversations SET is_pinned = 1, group_id = 'system:pinned' WHERE id = ?",
+      pinned.id,
+    );
+    const newer = createConversation("newer-1");
+    setLastMessageAt(pinned.id, 1000);
+    setLastMessageAt(newer.id, 2000);
+
+    const result = (await invoke({
+      conversationType: "all",
+      limit: "1",
+    })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["newer-1"]);
+    expect(result.hasMore).toBe(true);
+  });
+
+  test("hasMore describes the combined total, so pagination drains it", async () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    const first = (await invoke({
+      conversationType: "all",
+      limit: "2",
+    })) as ListResponse;
+    expect(first.conversations).toHaveLength(2);
+    expect(first.hasMore).toBe(true);
+
+    const second = (await invoke({
+      conversationType: "all",
+      limit: "2",
+      offset: String(first.nextOffset),
+    })) as ListResponse;
+    expect(second.conversations).toHaveLength(1);
+    expect(second.hasMore).toBe(false);
+  });
+});