@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/src/instrument.ts

@@ -7,6 +7,7 @@ import {
   getPlatformUserId,
   getSentryDsn,
 } from "./config/env.js";
+import { getCachedShareDiagnostics } from "./platform/consent-cache.js";
 import { APP_VERSION, COMMIT_SHA } from "./version.js";
 
 /** Patterns that match sensitive data in Sentry event values. */
@@ -41,9 +42,11 @@ function redactObject(obj: unknown): unknown {
 /**
  * Call after dotenv has loaded so SENTRY_DSN_ASSISTANT is available.
  * Initializes Sentry when the DSN is set; no-ops when empty/unset so
- * local dev builds don't send crash reports. If the user later opts out
- * via the sendDiagnostics config key (or VELLUM_DEV=1), call closeSentry()
- * after config is loaded to stop future event capturing.
+ * local dev builds don't send crash reports. Events are dropped by
+ * beforeSend until the platform share_diagnostics consent confirms opt-in
+ * (re-read from the consent cache per event, so a revocation takes effect
+ * within one refresh cycle); VELLUM_DEV=1 and legacyDiagnosticsOptOut
+ * hard-disable via closeSentry() after config loads.
  */
 export function initSentry(): void {
   const dsn = getSentryDsn();
@@ -54,6 +57,14 @@ export function initSentry(): void {
     dist: COMMIT_SHA,
     environment: process.env.VELLUM_ENVIRONMENT ?? "production",
     sendDefaultPii: false,
+    // Fail-closed: suppress client-report pings (discarded-event counts) so an
+    // assistant with unconfirmed share_diagnostics consent stays network-silent.
+    sendClientReports: false,
+    // Drop the default ProcessSession integration: it starts a release-health
+    // session on init and flushes a session envelope on process exit (a network
+    // request not covered by the beforeSend event gate), violating fail-closed.
+    integrations: (defaults) =>
+      defaults.filter((i) => i.name !== "ProcessSession"),
     serverName: hostname(),
     initialScope: {
       tags: {
@@ -77,6 +88,7 @@ export function initSentry(): void {
       },
     },
     beforeSend(event) {
+      if (!getCachedShareDiagnostics()) return null;
       if (event.exception?.values) {
         event.exception.values = event.exception.values.map((ex) => ({
           ...ex,
@@ -101,9 +113,9 @@ export function initSentry(): void {
 }
 
 /**
- * Stop capturing future Sentry events. Called after config loads when the
- * user has disabled sendDiagnostics so that early-startup crashes are
- * still captured but subsequent events are suppressed.
+ * Stop capturing future Sentry events. Called after config loads for the
+ * legacyDiagnosticsOptOut local opt-out (or VELLUM_DEV=1) to hard-disable
+ * crash reporting independent of the share_diagnostics consent gate.
  */
 export async function closeSentry(): Promise<void> {
   await Sentry.close();

package/src/ipc/__tests__/binary-result-ipc.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Unit tests for how `AssistantIpcServer.sendResult` handles a binary or
+ * streaming handler result over the IPC transport.
+ *
+ * A `RouteResponse` (or a bare `Uint8Array` / `ReadableStream` / `Blob`)
+ * wraps raw bytes that can't be carried as a JSON `result` field. Rather than
+ * silently serialize the body into garbage, the server reports a structured
+ * `BINARY_UNSUPPORTED_OVER_IPC` error; the gateway IPC proxy uses that signal
+ * to fall back to the HTTP proxy, which streams binary responses correctly.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { RouteResponse } from "../../runtime/routes/types.js";
+import { AssistantIpcServer } from "../assistant-server.js";
+
+/**
+ * `sendResult` is private; access it through an interface cast so the test
+ * exercises the real production path without a test-only API on the class.
+ */
+type PrivateApi = {
+  sendResult(
+    socket: unknown,
+    reader: unknown,
+    requestId: string,
+    value: unknown,
+  ): void;
+};
+
+/**
+ * Drive `sendResult` with a capturing socket in legacy (newline-delimited
+ * JSON) mode — the same wire shape the gateway's IPC client speaks — and
+ * return the parsed response envelope.
+ */
+function captureSendResult(value: unknown): Record<string, unknown> {
+  const server = new AssistantIpcServer() as unknown as PrivateApi;
+  const writes: string[] = [];
+  const socket = {
+    destroyed: false,
+    write: (chunk: string) => {
+      writes.push(chunk);
+      return true;
+    },
+  };
+  const reader = { isLegacy: true };
+
+  server.sendResult(socket, reader, "req-1", value);
+
+  expect(writes).toHaveLength(1);
+  return JSON.parse(writes[0]) as Record<string, unknown>;
+}
+
+describe("AssistantIpcServer.sendResult binary handling", () => {
+  test("a binary RouteResponse is reported as BINARY_UNSUPPORTED_OVER_IPC", () => {
+    const env = captureSendResult(
+      new RouteResponse(new Uint8Array([137, 80, 78, 71]), {
+        "content-type": "image/png",
+      }),
+    );
+
+    expect(env.id).toBe("req-1");
+    expect(env.statusCode).toBe(421);
+    expect(env.errorCode).toBe("BINARY_UNSUPPORTED_OVER_IPC");
+    // The binary body must never be JSON-serialized into a `result` field.
+    expect("result" in env).toBe(false);
+  });
+
+  test("a bare Uint8Array result is also reported as unsupported", () => {
+    const env = captureSendResult(new Uint8Array([1, 2, 3]));
+
+    expect(env.errorCode).toBe("BINARY_UNSUPPORTED_OVER_IPC");
+    expect("result" in env).toBe(false);
+  });
+
+  test("a plain JSON result still serializes into `result`", () => {
+    const env = captureSendResult({ ok: true, count: 2 });
+
+    expect(env.result).toEqual({ ok: true, count: 2 });
+    expect(env.errorCode).toBeUndefined();
+  });
+});

package/src/ipc/__tests__/clients-list-ipc.test.ts

@@ -166,4 +166,24 @@ describe("assistant clients list over IPC — same-user filter", () => {
     const ids = parsed.clients.map((c) => c.clientId).sort();
     expect(ids).toEqual(["client-other", "client-self"]);
   });
+
+  test("--json output carries the degraded flag (false for fresh clients)", async () => {
+    registerClient({
+      clientId: "client-self-1",
+      actorPrincipalId: "guardian-local",
+    });
+
+    await startServer();
+
+    const { stdout } = await runAssistantCommandFull(
+      "clients",
+      "list",
+      "--json",
+    );
+    const parsed = JSON.parse(stdout.trim()) as {
+      clients: Array<{ clientId: string; degraded?: boolean }>;
+    };
+    expect(parsed.clients).toHaveLength(1);
+    expect(parsed.clients[0].degraded).toBe(false);
+  });
 });

package/src/ipc/assistant-server.ts

@@ -31,10 +31,7 @@
 import { existsSync, unlinkSync } from "node:fs";
 import { createServer, type Server, type Socket } from "node:net";
 
-import {
-  ensureSocketDir,
-  SocketWatchdog,
-} from "@vellumai/ipc-server-utils";
+import { ensureSocketDir, SocketWatchdog } from "@vellumai/ipc-server-utils";
 
 import { findLocalGuardianPrincipalId } from "../runtime/local-actor-identity.js";
 import { RouteError } from "../runtime/routes/errors.js";
@@ -43,6 +40,7 @@ import type {
   RouteDefinition,
   RouteHandlerArgs,
 } from "../runtime/routes/types.js";
+import { RouteResponse } from "../runtime/routes/types.js";
 import { getLogger } from "../util/logger.js";
 import {
   type IpcEnvelope,
@@ -134,6 +132,26 @@ function isIpcBinaryResponse(value: unknown): value is IpcBinaryResponse {
   );
 }
 
+/**
+ * A handler result whose body is raw bytes or a stream rather than a JSON
+ * value — `RouteResponse` (e.g. `workspace/file/content` returns a
+ * `Bun.file`), or a bare `Uint8Array` / `ReadableStream` / `Blob`.
+ *
+ * These cannot be carried as a JSON `result` field, so over the IPC
+ * transport they are reported as a structured error rather than silently
+ * JSON-serialized into garbage. Distinct from the `IpcBinaryResponse` /
+ * `IpcStreamingResponse` wrappers, which are explicit binary envelopes the
+ * framing protocol does transmit.
+ */
+function isNonJsonIpcResult(value: unknown): boolean {
+  return (
+    value instanceof RouteResponse ||
+    value instanceof Uint8Array ||
+    value instanceof ReadableStream ||
+    value instanceof Blob
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Server
 // ---------------------------------------------------------------------------
@@ -401,6 +419,8 @@ export class AssistantIpcServer {
    * Route a handler result to the appropriate send path:
    * - IpcStreamingResponse → chunked binary frames
    * - IpcBinaryResponse → single binary frame with content-length
+   * - A raw binary/stream result (RouteResponse, Uint8Array, ...) → structured
+   *   BINARY_UNSUPPORTED_OVER_IPC error (the transport can't carry it as JSON)
    * - Everything else → JSON response
    */
   private sendResult(
@@ -420,6 +440,19 @@ export class AssistantIpcServer {
         },
       };
       this.sendResponse(socket, reader, envelope, value.binary);
+    } else if (isNonJsonIpcResult(value)) {
+      // A binary/streaming handler result (e.g. a file-content RouteResponse
+      // wrapping a Bun.file) cannot be carried as a JSON `result`. Report a
+      // structured error instead of silently serializing it into garbage; the
+      // gateway IPC proxy treats this code as a signal to retry over HTTP,
+      // which streams binary correctly.
+      this.sendResponse(socket, reader, {
+        id: requestId,
+        error:
+          "Binary/streaming responses are not supported over the IPC transport; use HTTP",
+        statusCode: 421,
+        errorCode: "BINARY_UNSUPPORTED_OVER_IPC",
+      });
     } else {
       this.sendResponse(socket, reader, { id: requestId, result: value });
     }

package/src/ipc/gateway-flag-listener.ts

@@ -1,7 +1,9 @@
 import { connect, type Socket } from "node:net";
 
 import { refreshOverridesFromGateway } from "../config/assistant-feature-flags.js";
+import { reconcileFlagGatedProfiles } from "../config/sync-gated-profiles.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
+import { publishConfigChanged } from "../runtime/sync/resource-sync-events.js";
 import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
 import { syncFlagGatedTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
@@ -19,11 +21,25 @@ const log = getLogger("gateway-flag-listener");
  * they live in a flag-gated bundled skill surfaced via `skill_load` against the
  * live flag cache, so they need no registry sync here. `syncFlagGatedTools` is
  * idempotent and enable-only, so re-running it on every refresh is safe; it also
- * never throws (it logs internally).
+ * never throws (it logs internally). After tools sync, `reconcileFlagGatedProfiles`
+ * adds or removes the flag-gated managed profile (OS Beta); when it reports a
+ * change a `config_changed` broadcast refreshes the profile picker on clients.
+ * The profile reconcile runs only when the refresh confirmed flags loaded from
+ * the gateway — a transient IPC failure leaves the cache unset and resolves
+ * `os-beta` to its registry default `false`, which would remove the user's
+ * profile and reset their selection. Tool sync tolerates the default and stays
+ * unconditional.
  */
 function refreshFlagsAndSyncTools(context: string): void {
   refreshOverridesFromGateway()
-    .then(() => syncFlagGatedTools())
+    .then(async (loaded) => {
+      await syncFlagGatedTools();
+      if (loaded && reconcileFlagGatedProfiles()) {
+        // Reuse the config-changed broadcast clients already consume so the
+        // profile picker reflects the added/removed managed profile.
+        publishConfigChanged();
+      }
+    })
     .catch((err) => {
       log.warn(
         { err },

package/src/memory/__tests__/auto-analysis-enqueue.test.ts

@@ -76,17 +76,6 @@ mock.module("../jobs-store.js", () => ({
   },
 }));
 
-// Mirror production semantics from `isUntrustedTrustClass` in
-// actor-trust-resolver.ts: anything that isn't `guardian` is untrusted.
-// Keeping these in sync guards the compaction trust boundary — a drifting
-// mock would let regressions pass as false positives.
-mock.module("../../runtime/actor-trust-resolver.js", () => ({
-  isUntrustedTrustClass: (trustClass: string | undefined) =>
-    trustClass === "trusted_contact" ||
-    trustClass === "unknown" ||
-    trustClass === undefined,
-}));
-
 import {
   enqueueAutoAnalysisIfEnabled,
   enqueueAutoAnalysisOnCompaction,
@@ -315,9 +304,9 @@ describe("enqueueAutoAnalysisOnCompaction", () => {
   });
 
   test("undefined trust class — skips (fail-closed when trust is unresolved)", () => {
-    // `isUntrustedTrustClass(undefined)` is true in production, so
-    // compaction-triggered analysis must NOT fire when the caller cannot
-    // establish a trust class.
+    // `resolveCapabilities(undefined).canAccessMemory` is false in
+    // production, so compaction-triggered analysis must NOT fire when the
+    // caller cannot establish a trust class.
     enqueueAutoAnalysisOnCompaction("c1", undefined);
 
     expect(enqueueCalls).toHaveLength(0);
@@ -332,8 +321,8 @@ describe("enqueueAutoAnalysisOnCompaction", () => {
   });
 
   test("trusted_contact trust class — skips (only guardian is trusted)", () => {
-    // trusted_contact is in the untrusted set per production
-    // `isUntrustedTrustClass`, so compaction-triggered analysis must NOT
+    // trusted_contact lacks `canAccessMemory` per production
+    // `resolveCapabilities`, so compaction-triggered analysis must NOT
     // fire. Only `guardian` passes the gate.
     enqueueAutoAnalysisOnCompaction("c1", "trusted_contact");
 

package/src/memory/__tests__/jobs-store-enqueue-gate.test.ts

@@ -48,14 +48,12 @@ mock.module("../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: () => true,
 }));
 
-// Stub trust resolver — never claim the actor is untrusted in tests.
-mock.module("../../runtime/actor-trust-resolver.js", () => ({
-  isUntrustedTrustClass: () => false,
-}));
-
 // Stub the conversation-source lookup so the recursion guards in the
 // retrospective and auto-analysis paths fall through to the enqueue.
+// `getConversation` returning null keeps `isLowYieldRetrospectiveSource`
+// false, so the retrospective is enqueued rather than skipped.
 mock.module("../conversation-crud.js", () => ({
+  getConversation: () => null,
   getConversationSource: () => null,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
@@ -117,12 +115,10 @@ mock.module("../db-connection.js", () => ({
 
 // Now load the real modules under test.
 const { isMemoryEnabled } = await import("../jobs-store.js");
-const { enqueueAutoAnalysisIfEnabled } = await import(
-  "../auto-analysis-enqueue.js"
-);
-const { enqueueMemoryRetrospectiveIfEnabled } = await import(
-  "../memory-retrospective-enqueue.js"
-);
+const { enqueueAutoAnalysisIfEnabled } =
+  await import("../auto-analysis-enqueue.js");
+const { enqueueMemoryRetrospectiveIfEnabled } =
+  await import("../memory-retrospective-enqueue.js");
 
 beforeEach(() => {
   dbInserts.length = 0;

package/src/memory/__tests__/memory-retrospective-enqueue.test.ts

@@ -12,6 +12,8 @@ mock.module("../../util/logger.js", () => ({
 // ---------------------------------------------------------------------------
 
 let sourceTag: string | null = null;
+let convType = "standard";
+let convSource = "user";
 const upsertCalls: Array<{
   payload: { conversationId: string };
   runAfter: number;
@@ -19,6 +21,10 @@ const upsertCalls: Array<{
 
 mock.module("../conversation-crud.js", () => ({
   getConversationSource: (_id: string) => sourceTag,
+  getConversation: (_id: string) => ({
+    conversationType: convType,
+    source: convSource,
+  }),
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
@@ -31,13 +37,6 @@ mock.module("../jobs-store.js", () => ({
   },
 }));
 
-mock.module("../../runtime/actor-trust-resolver.js", () => ({
-  isUntrustedTrustClass: (trustClass: string | undefined) =>
-    trustClass === "trusted_contact" ||
-    trustClass === "unknown" ||
-    trustClass === undefined,
-}));
-
 import {
   enqueueMemoryRetrospectiveIfEnabled,
   enqueueMemoryRetrospectiveOnCompaction,
@@ -47,6 +46,8 @@ import {
 describe("enqueueMemoryRetrospectiveIfEnabled", () => {
   beforeEach(() => {
     sourceTag = null;
+    convType = "standard";
+    convSource = "user";
     upsertCalls.length = 0;
   });
 
@@ -85,6 +86,35 @@ describe("enqueueMemoryRetrospectiveIfEnabled", () => {
     });
     expect(upsertCalls).toHaveLength(0);
   });
+
+  test("scheduled conversation — skips enqueue", () => {
+    convType = "scheduled";
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "interval",
+    });
+    expect(upsertCalls).toHaveLength(0);
+  });
+
+  test("memory_v2_consolidation source — skips enqueue", () => {
+    convType = "background";
+    convSource = "memory_v2_consolidation";
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "interval",
+    });
+    expect(upsertCalls).toHaveLength(0);
+  });
+
+  test("heartbeat (background) source — still enqueues", () => {
+    convType = "background";
+    convSource = "heartbeat";
+    enqueueMemoryRetrospectiveIfEnabled({
+      conversationId: "c1",
+      trigger: "interval",
+    });
+    expect(upsertCalls).toHaveLength(1);
+  });
 });
 
 describe("isMemoryRetrospectiveConversation", () => {

package/src/memory/__tests__/memory-retrospective-job.test.ts

@@ -685,6 +685,40 @@ describe("memoryRetrospectiveJob", () => {
     expect(wakeCalls[0]!.opts.toolGateMode).toBe("execution");
   });
 
+  // -------------------------------------------------------------------------
+  // Source background-turn parity (isNonInteractive)
+  // -------------------------------------------------------------------------
+
+  test("background source → wake runs non-interactive (reproduces <background_turn>)", async () => {
+    conversationOverrides["src-conv-1"] = {
+      source: "heartbeat",
+      forkParentMessageId: null,
+      title: "Heartbeat",
+      conversationType: "background",
+    };
+
+    const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(outcome.kind).toBe("invoked");
+    expect(wakeCalls).toHaveLength(1);
+    expect(wakeCalls[0]!.opts.isNonInteractive).toBe(true);
+  });
+
+  test("standard source → wake stays interactive (no spurious <background_turn>)", async () => {
+    conversationOverrides["src-conv-1"] = {
+      source: "user",
+      forkParentMessageId: null,
+      title: "Source conversation",
+      conversationType: "standard",
+    };
+
+    const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(outcome.kind).toBe("invoked");
+    expect(wakeCalls).toHaveLength(1);
+    expect(wakeCalls[0]!.opts.isNonInteractive).toBe(false);
+  });
+
   // -------------------------------------------------------------------------
   // Source-derived persona override
   // -------------------------------------------------------------------------

package/src/memory/__tests__/onboarding-events-store.test.ts

@@ -8,10 +8,10 @@ mock.module("../../util/logger.js", () => ({
     }),
 }));
 
-// Mutable usage-data gate, flipped per-test.
-let collectUsageData = true;
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => ({ collectUsageData }),
+// Mutable consent gate, flipped per-test.
+let shareAnalytics = true;
+mock.module("../../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => shareAnalytics,
 }));
 
 import { getDb } from "../db-connection.js";
@@ -30,7 +30,7 @@ function resetTable(): void {
 
 describe("onboarding-events-store: recordActivationEvent", () => {
   beforeEach(() => {
-    collectUsageData = true;
+    shareAnalytics = true;
     resetTable();
   });
 
@@ -66,8 +66,8 @@ describe("onboarding-events-store: recordActivationEvent", () => {
     expect(rows[0]!.stepIndex).toBe(2);
   });
 
-  test("returns null and writes no row when collectUsageData is disabled", () => {
-    collectUsageData = false;
+  test("returns null and writes no row when share_analytics is disabled", () => {
+    shareAnalytics = false;
     const event = recordActivationEvent({
       stepName: "activation_moment_1_complete",
       sessionId: "conv-3",

package/src/memory/auth-fallback-events-store.ts

@@ -1,7 +1,7 @@
 import { and, asc, eq, gt, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getConfig } from "../config/loader.js";
+import { getCachedShareAnalytics } from "../platform/consent-cache.js";
 import { getDb } from "./db-connection.js";
 import { authFallbackEvents } from "./schema.js";
 
@@ -36,7 +36,7 @@ export function recordAuthFallbackCounts(
   windowEnd: number,
   counts: AuthFallbackCount[],
 ): number {
-  if (!getConfig().collectUsageData) return 0;
+  if (!getCachedShareAnalytics()) return 0;
   if (counts.length === 0) return 0;
   const db = getDb();
   const createdAt = Date.now();

package/src/memory/auto-analysis-enqueue.ts

@@ -1,9 +1,7 @@
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
-import {
-  isUntrustedTrustClass,
-  type TrustClass,
-} from "../runtime/actor-trust-resolver.js";
+import { type TrustClass } from "../runtime/actor-trust-resolver.js";
+import { resolveCapabilities } from "../runtime/capabilities.js";
 import { getLogger } from "../util/logger.js";
 import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
 import { isMemoryEnabled, upsertAutoAnalysisJob } from "./jobs-store.js";
@@ -118,7 +116,7 @@ export function enqueueAutoAnalysisOnCompaction(
   conversationId: string,
   trustClass: TrustClass | undefined,
 ): void {
-  if (isUntrustedTrustClass(trustClass)) {
+  if (!resolveCapabilities(trustClass).canAccessMemory) {
     return;
   }
   try {

package/src/memory/canonical-guardian-store.ts

@@ -74,7 +74,7 @@ export interface CanonicalGuardianRequest {
   updatedAt: number;
 }
 
-interface CanonicalGuardianDelivery {
+export interface CanonicalGuardianDelivery {
   id: string;
   requestId: string;
   destinationChannel: string;
@@ -674,6 +674,44 @@ export function listPendingCanonicalGuardianRequestsByDestinationChat(
   return pendingRequests;
 }
 
+/**
+ * Find the pending canonical request whose guardian-facing delivery landed on a
+ * specific channel message (channel + chat + message id).
+ *
+ * This is the addressing key for emoji-reaction decisions: a reaction carries
+ * only the message it is attached to, so the delivered card's message id is how
+ * we recover which request the guardian acted on — even when several cards are
+ * pending in the same chat. Returns null when no delivery matches or the matched
+ * request is no longer pending.
+ */
+export function getPendingCanonicalRequestByDestinationMessage(
+  destinationChannel: string,
+  destinationChatId: string,
+  destinationMessageId: string,
+): CanonicalGuardianRequest | null {
+  const db = getDb();
+
+  const delivery = db
+    .select()
+    .from(canonicalGuardianDeliveries)
+    .where(
+      and(
+        eq(canonicalGuardianDeliveries.destinationChannel, destinationChannel),
+        eq(canonicalGuardianDeliveries.destinationChatId, destinationChatId),
+        eq(
+          canonicalGuardianDeliveries.destinationMessageId,
+          destinationMessageId,
+        ),
+      ),
+    )
+    .get();
+
+  if (!delivery) return null;
+
+  const request = getCanonicalGuardianRequest(delivery.requestId);
+  return request && request.status === "pending" ? request : null;
+}
+
 // ---------------------------------------------------------------------------
 // Conversation scope helpers
 // ---------------------------------------------------------------------------

package/src/memory/conversation-crud.ts

@@ -129,7 +129,7 @@ export const messageMetadataSchema = z
      * and read gate (conversation history loading) to enforce trust-aware access.
      */
     provenanceTrustClass: z
-      .enum(["guardian", "trusted_contact", "unknown"])
+      .enum(["guardian", "trusted_contact", "unverified_contact", "unknown"])
       .optional(),
     provenanceSourceChannel: channelIdSchema.optional(),
     provenanceGuardianExternalUserId: z.string().optional(),
@@ -2575,12 +2575,17 @@ export function getConversationOriginInterface(
  * in the given conversation, or `undefined` if none is found.
  *
  * Used by the pointer message trust resolver to detect conversations
- * whose audience is a guardian or trusted_contact outside desktop-origin
- * conversations.
+ * whose audience is a guardian, trusted_contact, or unverified_contact
+ * outside desktop-origin conversations.
  */
 export function getConversationRecentProvenanceTrustClass(
   conversationId: string,
-): "guardian" | "trusted_contact" | "unknown" | undefined {
+):
+  | "guardian"
+  | "trusted_contact"
+  | "unverified_contact"
+  | "unknown"
+  | undefined {
   const row = rawGet<{ metadata: string | null }>(
     `SELECT metadata FROM messages
      WHERE conversation_id = ? AND role = 'user' AND metadata IS NOT NULL