@vellumai/assistant 0.4.48 → 0.4.50

package/src/__tests__/date-context.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   buildTemporalContext,
-  extractUserTimeZoneFromDynamicProfile,
+  extractUserTimeZoneFromRecall,
 } from "../daemon/date-context.js";
 
 // Fixed timestamps for deterministic assertions (all UTC midday to avoid DST edge cases).
@@ -152,82 +152,6 @@ describe("buildTemporalContext", () => {
   });
 });
 
-describe("extractUserTimeZoneFromDynamicProfile", () => {
-  test("extracts canonical timezone from explicit timezone profile line", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: Timezone is America/New_York.",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe(
-      "America/New_York",
-    );
-  });
-
-  test("extracts timezone token from generic profile text when explicit line is absent", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- location: Travels often between Europe and Asia (currently Europe/Paris).",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Europe/Paris");
-  });
-
-  test("returns null when no valid timezone is present", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: Pacific time",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBeNull();
-  });
-
-  test("extracts UTC/GMT offset tokens from explicit timezone profile line", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: UTC+2",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Etc/GMT-2");
-  });
-
-  test("extracts GMT negative offset tokens from generic profile text", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- preferences: schedule notifications in GMT-5 whenever possible.",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Etc/GMT+5");
-  });
-
-  test("extracts fractional UTC offset tokens from explicit timezone profile line", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: UTC+5:30",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("+05:30");
-  });
-
-  test("extracts fractional GMT offset tokens from generic profile text", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- preferences: default reminders to GMT+5:45.",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("+05:45");
-  });
-
-  test("prefers IANA timezone tokens over UTC/GMT offsets in the same profile line", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: UTC+1 (Europe/Paris)",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Europe/Paris");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Weekday baseline — today is Wednesday
 // ---------------------------------------------------------------------------
@@ -615,3 +539,95 @@ describe("trip-planning: timezone-shifted weekend anchors", () => {
     expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 });
+
+// ---------------------------------------------------------------------------
+// extractUserTimeZoneFromRecall
+// ---------------------------------------------------------------------------
+
+describe("extractUserTimeZoneFromRecall", () => {
+  test("returns null for empty input", () => {
+    expect(extractUserTimeZoneFromRecall("")).toBeNull();
+    expect(extractUserTimeZoneFromRecall("  ")).toBeNull();
+  });
+
+  test("extracts IANA timezone from user_identity section", () => {
+    const text = `<memory_context>
+
+<user_identity>
+User's timezone is America/New_York
+User works as a software engineer
+</user_identity>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("America/New_York");
+  });
+
+  test("extracts timezone from 'timezone: ...' line in identity", () => {
+    const text = `<memory_context>
+
+<user_identity>
+- name: Alice
+- timezone: Europe/London
+- role: designer
+</user_identity>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("Europe/London");
+  });
+
+  test("extracts UTC offset timezone", () => {
+    const text = `<memory_context>
+
+<user_identity>
+User's time zone is UTC+5:30
+</user_identity>
+
+</memory_context>`;
+    const result = extractUserTimeZoneFromRecall(text);
+    expect(result).not.toBeNull();
+    // UTC+5:30 should canonicalize to +05:30
+    expect(result).toBe("+05:30");
+  });
+
+  test("falls back to scanning full text when no identity section", () => {
+    const text = `<memory_context>
+
+<relevant_context>
+<episode source="Mar 5">
+User mentioned their timezone is Asia/Tokyo
+</episode>
+</relevant_context>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("Asia/Tokyo");
+  });
+
+  test("returns null when no timezone info present", () => {
+    const text = `<memory_context>
+
+<user_identity>
+User's name is Bob
+User works at Acme Corp
+</user_identity>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBeNull();
+  });
+
+  test("prefers identity section over other sections", () => {
+    const text = `<memory_context>
+
+<user_identity>
+User's timezone is America/Chicago
+</user_identity>
+
+<relevant_context>
+<episode source="Mar 5">
+Discussed timezone America/Los_Angeles for the deployment
+</episode>
+</relevant_context>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("America/Chicago");
+  });
+});

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -399,4 +399,68 @@ describe("Verification control messages are deterministic (guard)", () => {
       globalThis.fetch = originalFetch;
     }
   });
+
+  test("handleChannelInbound does not allow blocked members to bootstrap with /start gv_<token>", async () => {
+    const { createHash, randomBytes } = await import("node:crypto");
+    const { handleChannelInbound } =
+      await import("../runtime/routes/inbound-message-handler.js");
+    const { createOutboundSession } =
+      await import("../runtime/channel-verification-service.js");
+    const { upsertContactChannel } =
+      await import("../contacts/contacts-write.js");
+
+    const blockedIdentity = {
+      sourceChannel: "telegram",
+      externalUserId: "user-blocked-bootstrap",
+      externalChatId: "chat-blocked-bootstrap",
+      displayName: "Blocked Bootstrap User",
+      status: "blocked",
+      policy: "deny",
+    } as const;
+    upsertContactChannel(blockedIdentity);
+
+    const bootstrapToken = randomBytes(16).toString("hex");
+    const bootstrapTokenHash = createHash("sha256")
+      .update(bootstrapToken)
+      .digest("hex");
+
+    createOutboundSession({
+      channel: "telegram",
+      identityBindingStatus: "pending_bootstrap",
+      destinationAddress: blockedIdentity.externalUserId,
+      bootstrapTokenHash,
+    });
+
+    let processMessageCalled = false;
+    const processMessage = async () => {
+      processMessageCalled = true;
+      return { messageId: "msg-1" };
+    };
+
+    const req = new Request("http://localhost/channels/inbound", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sourceChannel: "telegram",
+        interface: "telegram",
+        conversationExternalId: blockedIdentity.externalChatId,
+        externalMessageId: `msg-blocked-bootstrap-${Date.now()}`,
+        content: `/start gv_${bootstrapToken}`,
+        actorExternalId: blockedIdentity.externalUserId,
+        actorDisplayName: blockedIdentity.displayName,
+        sourceMetadata: {
+          commandIntent: { type: "start", payload: `gv_${bootstrapToken}` },
+        },
+      }),
+    });
+
+    const response = await handleChannelInbound(req, processMessage);
+    const body = (await response.json()) as Record<string, unknown>;
+
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBe(true);
+    expect(body.reason).toBe("member_blocked");
+    expect(body.verificationOutcome).toBeUndefined();
+    expect(processMessageCalled).toBe(false);
+  });
 });

package/src/__tests__/dynamic-skill-workflow-prompt.test.ts

@@ -46,7 +46,6 @@ mock.module("../util/logger.js", () => ({
   ...realLogger,
   getLogger: () => noopLogger,
   getCliLogger: () => noopLogger,
-  isDebug: () => false,
   truncateForLog: (v: string) => v,
   initLogger: () => {},
   pruneOldLogFiles: () => 0,

package/src/__tests__/ephemeral-permissions.test.ts

@@ -328,11 +328,11 @@ describe("ephemeral-permissions", () => {
       testConfig.permissions.mode = "workspace";
     });
 
-    test("workspace mode auto-allows workspace-scoped file_write (medium risk)", async () => {
+    test("workspace mode prompts for workspace-scoped file_write (medium risk)", async () => {
       const filePath = join(testDir, "workspace-test-file.txt");
       const result = await check("file_write", { path: filePath }, testDir);
-      expect(result.decision).toBe("allow");
-      expect(result.reason).toContain("Workspace mode");
+      expect(result.decision).toBe("prompt");
+      expect(result.reason).toContain("medium risk");
     });
 
     test("workspace mode still prompts for file_write outside workspace", async () => {

package/src/__tests__/gateway-only-guard.test.ts

@@ -37,7 +37,6 @@ const ALLOWLIST = new Set([
   // --- Documentation and comments that mention the port for explanatory purposes ---
   "AGENTS.md", // documents the gateway-only rule itself
   "ARCHITECTURE.md", // architecture overview with port references
-  "assistant/docs/runbook-trusted-contacts.md", // operator runbook targeting runtime-only /v1/contacts endpoints
   "assistant/src/runtime/middleware/twilio-validation.ts", // comment explaining proxy URL rewriting
 ]);
 

package/src/__tests__/guardian-action-grant-mint-consume.test.ts

@@ -35,7 +35,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/guardian-decision-primitive-canonical.test.ts

@@ -21,7 +21,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -42,7 +42,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 
@@ -1428,3 +1427,96 @@ describe("routing invariant: invite handoff bypass for access requests", () => {
     expect(resolved!.status).toBe("approved");
   });
 });
+
+// ===========================================================================
+// SECTION 11: Expired requests are excluded from routing
+// ===========================================================================
+
+describe("routing invariant: expired requests are excluded from pending discovery", () => {
+  beforeEach(() => resetTables());
+
+  test("expired request with hinted IDs is excluded from disambiguation", async () => {
+    const expired = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "EXP001",
+      toolName: "shell",
+      expiresAt: new Date(Date.now() - 10_000).toISOString(),
+    });
+
+    const active = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "ACT001",
+      toolName: "file_write",
+      expiresAt: new Date(Date.now() + 60_000).toISOString(),
+    });
+    registerPendingToolApprovalInteraction(active.id, "conv-1", "file_write");
+
+    // Both IDs are hinted but only the active one should be considered
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "approve",
+        conversationId: "conv-guardian-thread",
+        pendingRequestIds: [expired.id, active.id],
+        approvalConversationGenerator: undefined,
+      }),
+    );
+
+    // Single active request — should apply directly, no disambiguation
+    expect(result.consumed).toBe(true);
+    expect(result.type).toBe("canonical_decision_applied");
+    expect(result.decisionApplied).toBe(true);
+
+    const resolvedActive = getCanonicalGuardianRequest(active.id);
+    expect(resolvedActive!.status).toBe("approved");
+
+    // Expired request untouched
+    const resolvedExpired = getCanonicalGuardianRequest(expired.id);
+    expect(resolvedExpired!.status).toBe("pending");
+  });
+
+  test("all expired hinted requests means no pending found — not consumed", async () => {
+    const expired1 = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "EXP002",
+      toolName: "shell",
+      expiresAt: new Date(Date.now() - 10_000).toISOString(),
+    });
+
+    const expired2 = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "EXP003",
+      toolName: "file_write",
+      expiresAt: new Date(Date.now() - 5_000).toISOString(),
+    });
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "approve",
+        conversationId: "conv-guardian-thread",
+        pendingRequestIds: [expired1.id, expired2.id],
+        approvalConversationGenerator: undefined,
+      }),
+    );
+
+    // No active pending requests — falls through
+    expect(result.consumed).toBe(false);
+    expect(result.type).toBe("not_consumed");
+    expect(result.decisionApplied).toBe(false);
+  });
+});

package/src/__tests__/guardian-verification-voice-binding.test.ts

@@ -57,7 +57,6 @@ mock.module("../security/secure-keys.js", () => ({
 
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
-  getTwilioUserPhoneNumber: () => null,
 }));
 
 mock.module("../inbound/public-ingress-urls.js", () => ({

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -147,7 +147,6 @@ import { handleConfirmationResponse } from "../daemon/handlers/sessions.js";
 
 interface TestSession {
   messages: Array<{ role: string; content: unknown[] }>;
-  hasEscalationHandler: () => boolean;
   setChannelCapabilities: (caps: unknown) => void;
   isProcessing: () => boolean;
   hasPendingConfirmation: (requestId: string) => boolean;
@@ -181,8 +180,6 @@ function createContext(session: TestSession): {
   const sent: ServerMessage[] = [];
   const ctx: HandlerContext = {
     sessions: new Map(),
-    cuSessions: new Map(),
-    cuObservationParseSequence: new Map(),
     sharedRequestTimestamps: [],
     debounceTimers: new DebouncerMap({ defaultDelayMs: 100 }),
     suppressConfigReload: false,
@@ -202,7 +199,6 @@ function createContext(session: TestSession): {
 function makeSession(overrides: Partial<TestSession> = {}): TestSession {
   return {
     messages: [],
-    hasEscalationHandler: () => true,
     setChannelCapabilities: () => {},
     isProcessing: () => false,
     hasPendingConfirmation: () => true,
@@ -277,39 +273,4 @@ describe("handleConfirmationResponse canonical status sync", () => {
     );
     expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow");
   });
-
-  test("syncs canonical status to denied for deny decisions in CU sessions", () => {
-    const cuSession = {
-      hasPendingConfirmation: (requestId: string) =>
-        requestId === "req-confirm-deny",
-      handleConfirmationResponse: mock(() => {}),
-    };
-    const { ctx } = createContext(
-      makeSession({
-        hasPendingConfirmation: () => false,
-      }),
-    );
-    ctx.cuSessions.set("cu-1", cuSession as any);
-
-    const msg: ConfirmationResponse = {
-      type: "confirmation_response",
-      requestId: "req-confirm-deny",
-      decision: "always_deny",
-    };
-
-    handleConfirmationResponse(msg, ctx);
-
-    expect(
-      (cuSession.handleConfirmationResponse as any).mock.calls.length,
-    ).toBe(1);
-    expect((cuSession.handleConfirmationResponse as any).mock.calls[0]).toEqual(
-      ["req-confirm-deny", "always_deny", undefined, undefined],
-    );
-    expect(resolveCanonicalGuardianRequestMock).toHaveBeenCalledWith(
-      "req-confirm-deny",
-      "pending",
-      { status: "denied" },
-    );
-    expect(resolveMock).toHaveBeenCalledWith("req-confirm-deny");
-  });
 });

package/src/__tests__/heartbeat-service.test.ts

@@ -67,7 +67,6 @@ mock.module("../util/logger.js", () => ({
     warn: () => {},
     error: () => {},
   }),
-  isDebug: () => false,
 }));
 
 // Mock conversation title service