@vellumai/assistant 0.8.2 → 0.8.3

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

@@ -65,10 +65,42 @@ mock.module("../conversation-crud.js", () => ({
   },
 }));
 
+let transcriptFormatterCalls: Array<{
+  messageIds: string[];
+  timeZone?: string;
+  assistantName?: string | null;
+  userName?: string | null;
+}> = [];
+
 mock.module("../../export/transcript-formatter.js", () => ({
   formatMessageSliceForTranscript: (
     messages: Array<{ id: string; createdAt: number }>,
-  ) => messages.map((m) => `[msg ${m.id}]`).join("\n"),
+    options: {
+      timeZone?: string;
+      assistantName?: string | null;
+      userName?: string | null;
+    } = {},
+  ) => {
+    transcriptFormatterCalls.push({
+      messageIds: messages.map((m) => m.id),
+      timeZone: options.timeZone,
+      assistantName: options.assistantName,
+      userName: options.userName,
+    });
+    return messages.map((m) => `[msg ${m.id}]`).join("\n");
+  },
+}));
+
+let mockAssistantName: string | null = "Bob";
+let mockUserName: string | null = "Alice";
+
+mock.module("../../daemon/identity-helpers.js", () => ({
+  getAssistantName: () => mockAssistantName,
+  resolveUserName: (_workspaceDir: string) => mockUserName,
+}));
+
+mock.module("../../util/platform.js", () => ({
+  getWorkspaceDir: () => "/tmp/test-workspace",
 }));
 
 mock.module("../conversation-bootstrap.js", () => ({
@@ -102,9 +134,19 @@ mock.module("../jobs-store.js", () => ({
 import type { MemoryJob } from "../jobs-store.js";
 import { memoryRetrospectiveJob } from "../memory-retrospective-job.js";
 
-const stubConfig = {
-  memory: { v2: { enabled: true } },
-} as unknown as Parameters<typeof memoryRetrospectiveJob>[1];
+function makeConfig(
+  overrides: { userTimezone?: string; detectedTimezone?: string } = {},
+): Parameters<typeof memoryRetrospectiveJob>[1] {
+  return {
+    memory: { v2: { enabled: true } },
+    ui: {
+      userTimezone: overrides.userTimezone,
+      detectedTimezone: overrides.detectedTimezone,
+    },
+  } as unknown as Parameters<typeof memoryRetrospectiveJob>[1];
+}
+
+const stubConfig = makeConfig();
 
 function makeJob(conversationId = "src-conv-1"): MemoryJob<{
   conversationId?: string;
@@ -155,6 +197,9 @@ describe("memoryRetrospectiveJob", () => {
     bootstrappedConversationId = "bg-conv-new";
     bootstrapCalls = [];
     deletedConversationIds = [];
+    transcriptFormatterCalls = [];
+    mockAssistantName = "Bob";
+    mockUserName = "Alice";
   });
 
   test("first-run happy path: no state row, no prior retrospective, both pointer fields set on success", async () => {
@@ -274,6 +319,44 @@ describe("memoryRetrospectiveJob", () => {
     expect(hint).toContain("- a real save");
   });
 
+  test("transcript is formatted in the configured user timezone and the prompt discloses it", async () => {
+    const config = makeConfig({ userTimezone: "America/Los_Angeles" });
+    await memoryRetrospectiveJob(makeJob(), config);
+
+    expect(transcriptFormatterCalls).toHaveLength(1);
+    expect(transcriptFormatterCalls[0]!.timeZone).toBe("America/Los_Angeles");
+
+    const hint = wakeCalls[0]!.hint;
+    expect(hint).toContain("Timestamps are in America/Los_Angeles.");
+  });
+
+  test("detected timezone is used when no manual override is set", async () => {
+    const config = makeConfig({ detectedTimezone: "Europe/Berlin" });
+    await memoryRetrospectiveJob(makeJob(), config);
+
+    expect(transcriptFormatterCalls[0]!.timeZone).toBe("Europe/Berlin");
+
+    const hint = wakeCalls[0]!.hint;
+    expect(hint).toContain("Timestamps are in Europe/Berlin.");
+  });
+
+  test("resolved assistant and user display names are passed to the transcript formatter", async () => {
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(transcriptFormatterCalls).toHaveLength(1);
+    expect(transcriptFormatterCalls[0]!.assistantName).toBe("Bob");
+    expect(transcriptFormatterCalls[0]!.userName).toBe("Alice");
+  });
+
+  test("formatter receives null names when identity files are missing — formatter handles fallback", async () => {
+    mockAssistantName = null;
+    mockUserName = null;
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(transcriptFormatterCalls[0]!.assistantName).toBeNull();
+    expect(transcriptFormatterCalls[0]!.userName).toBeNull();
+  });
+
   test("non-remember tool_use blocks in the prior retro are ignored", async () => {
     priorRetroId = "prior-retro-conv-1";
     priorRetroMessages = [

package/src/memory/conversation-queries.ts

@@ -1,4 +1,4 @@
-import { and, count, desc, eq, sql } from "drizzle-orm";
+import { and, count, desc, eq, inArray, isNull, sql } from "drizzle-orm";
 
 import {
   parseExternalContentEnvelope,
@@ -86,6 +86,92 @@ export function listConversations(
   return query.all().map(parseConversation);
 }
 
+/**
+ * List conversations matching an exact `source` value, ordered by `createdAt`
+ * descending. The surgical filter for "find every background run produced by
+ * job X" — heartbeat, memory_v2_consolidation, watcher-engine, etc. — since
+ * `source` is the canonical job-class distinguisher across the background
+ * bucket. `conversationType` + `group_id` only narrow to "background vs
+ * scheduled vs standard"; neither identifies which job produced the row.
+ *
+ * Filter is exact (no `LIKE`, no implicit exclusions): the route layer is
+ * responsible for knowing which source constants exist and passing one. The
+ * defensive `source != 'subagent'` carve-out applied by `listConversations`
+ * is deliberately NOT replicated here — a caller asking for an exact source
+ * gets exactly that source.
+ *
+ * @param source        Exact match against `conversations.source`. Pass the
+ *                      canonical constant (e.g. `MEMORY_V2_CONSOLIDATION_SOURCE`).
+ * @param limit         Maximum rows to return (default 20).
+ * @param opts.includeArchived  Include rows with non-null `archivedAt`.
+ *                              Defaults to `true` so callers that want a full
+ *                              run history get one; pass `false` for views
+ *                              that hide archived rows.
+ */
+export function listConversationsBySource(
+  source: string,
+  limit = 20,
+  opts?: { includeArchived?: boolean },
+): ConversationRow[] {
+  const db = getDb();
+  const includeArchived = opts?.includeArchived ?? true;
+  const where = includeArchived
+    ? eq(conversations.source, source)
+    : and(eq(conversations.source, source), isNull(conversations.archivedAt));
+  const rows = db
+    .select()
+    .from(conversations)
+    .where(where)
+    .orderBy(desc(conversations.createdAt))
+    .limit(limit)
+    .all();
+  return rows.map(parseConversation);
+}
+
+/**
+ * Per-conversation aggregate of messages with a specific role. Powers
+ * heartbeat-shaped run endpoints (e.g. `consolidation/runs`) that need a
+ * "did the agent emit any output?" signal stronger than
+ * `conversations.lastMessageAt` — which is bumped by the kickoff user
+ * prompt and so cannot distinguish "agent ran" from "agent dispatched but
+ * crashed before responding".
+ *
+ * Single batched aggregate query (no N+1). Conversations with zero matching
+ * messages are NOT present in the returned map — callers should treat a
+ * missing key as `{ count: 0, lastAt: null }`.
+ *
+ * @param conversationIds  Conversation ids to look up (empty → empty map).
+ * @param role             Message role to count (default `"assistant"`).
+ */
+export function getMessageRoleStatsByConversation(
+  conversationIds: string[],
+  role: string = "assistant",
+): Map<string, { count: number; lastAt: number }> {
+  if (conversationIds.length === 0) return new Map();
+  const db = getDb();
+  const rows = db
+    .select({
+      conversationId: messages.conversationId,
+      count: sql<number>`COUNT(*)`.as("count"),
+      lastAt: sql<number>`MAX(${messages.createdAt})`.as("last_at"),
+    })
+    .from(messages)
+    .where(
+      and(
+        inArray(messages.conversationId, conversationIds),
+        eq(messages.role, role),
+      ),
+    )
+    .groupBy(messages.conversationId)
+    .all();
+  return new Map(
+    rows.map((r) => [
+      r.conversationId,
+      { count: Number(r.count), lastAt: Number(r.lastAt) },
+    ]),
+  );
+}
+
 export function listPinnedConversations(): ConversationRow[] {
   ensureDisplayOrderMigration();
   ensureGroupMigration();

package/src/memory/conversation-title-service.ts

@@ -298,9 +298,11 @@ function buildTitleSystemPrompt(): string {
     "You generate ultra-concise conversation titles. Output ONLY the title text — no explanation, no quotes, no markdown, no preamble.",
     "",
     "Rules:",
-    "- 2–6 words. Titles longer than 6 words are unacceptable — ruthlessly compress",
-    "- Summarize the TOPIC, not the request or instructions",
-    "- Noun phrases are ideal (e.g. 'Auth Middleware Rewrite', 'Docker Volume Mounts')",
+    "- 2–5 words maximum. Titles longer than 5 words are unacceptable — ruthlessly compress to a short noun phrase",
+    "- 40 characters absolute maximum — if your title exceeds 40 characters it will be truncated and look broken",
+    "- Summarize only the TOPIC, not the request or instructions",
+    "- Noun phrases are ideal (e.g. 'Auth Middleware Rewrite', 'Docker Volume Mounts', 'Onboarding Flow')",
+    "- Think: what would make a scannable sidebar label?",
     "- Do NOT echo back what the user asked you to do",
     "- Do NOT respond to the conversation content",
     "- Do NOT assess feasibility or comment on capabilities",
@@ -353,13 +355,33 @@ const META_FAILURE_TITLES = new Set([
   "no content",
 ]);
 
+const MAX_TITLE_LENGTH = 40;
+const MAX_TITLE_WORDS = 7;
+
+function truncateTitle(title: string): string {
+  if (title.length <= MAX_TITLE_LENGTH) return title;
+  const words = title.split(/\s+/);
+  if (words.length <= MAX_TITLE_WORDS) {
+    // Long words but few of them — truncate to char limit at word boundary
+    let result = "";
+    for (const word of words) {
+      const candidate = result ? result + " " + word : word;
+      if (candidate.length > MAX_TITLE_LENGTH) break;
+      result = candidate;
+    }
+    return result || title.slice(0, MAX_TITLE_LENGTH);
+  }
+  // Too many words — trim to 5 words
+  return words.slice(0, 5).join(" ");
+}
+
 function normalizeTitle(raw: string): string {
   let title = raw.trim().replace(/^["']|["']$/g, "");
   title = stripMarkdown(title);
   if (META_FAILURE_TITLES.has(title.toLowerCase())) {
     return "";
   }
-  return title;
+  return truncateTitle(title);
 }
 
 /** Strip common markdown formatting so titles render as plain text. */

package/src/memory/db-init.ts

@@ -39,6 +39,7 @@ import {
   createWatchersAndLogsTables,
   migrate230AcpSessionHistory,
   migrate231RepairMemoryGraphEventDates,
+  migrateA2ATasks,
   migrateActivationState,
   migrateActivationStateFkCascade,
   migrateAddConversationInferenceProfile,
@@ -111,6 +112,7 @@ import {
   migrateHeartbeatRuns,
   migrateInviteCodeHashColumn,
   migrateInviteContactId,
+  migrateLlmRequestLogAgentLoopExitReason,
   migrateLlmRequestLogMessageId,
   migrateLlmRequestLogProvider,
   migrateLlmRequestLogsCreatedAtIndex,
@@ -142,6 +144,7 @@ import {
   migrateOAuthProvidersScopeSeparator,
   migrateOAuthProvidersTokenAuthMethodDefault,
   migrateOAuthProvidersTokenExchangeBodyFormat,
+  migrateProviderConnectionBaseUrlAndModels,
   migrateProviderConnectionStatusLabel,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
@@ -430,6 +433,9 @@ export function initializeDb(): void {
     migrateExternalConversationBindingThreadId,
     createOnboardingEventsTable,
     migrateNormalizeSlackExternalContent,
+    migrateProviderConnectionBaseUrlAndModels,
+    migrateA2ATasks,
+    migrateLlmRequestLogAgentLoopExitReason,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -177,7 +177,7 @@ const { migrateActivationState } =
   await import("../../migrations/232-activation-state.js");
 const schema = await import("../../schema.js");
 const { _resetMemoryV2QdrantForTests } = await import("../../v2/qdrant.js");
-const { hydrate: hydrateActivationState } =
+const { hydrate: hydrateActivationState, save: saveActivationState } =
   await import("../../v2/activation-store.js");
 
 // The wiring layer calls `getDb()` to fetch the SQLite handle. We mock
@@ -215,9 +215,14 @@ function createTestDb(): DrizzleDb {
   return db;
 }
 
-function makeConfig(v2Enabled: boolean): AssistantConfig {
+function makeConfig(v2Enabled: boolean, memoryEnabled = true): AssistantConfig {
+  // Pin `router.enabled: false` so these tests exercise the activation
+  // pipeline. Router-mode coverage lives in `memory/v2/__tests__/injection.test.ts`.
   return applyNestedDefaults({
-    memory: { v2: { enabled: v2Enabled } },
+    memory: {
+      enabled: memoryEnabled,
+      v2: { enabled: v2Enabled, router: { enabled: false } },
+    },
   }) as AssistantConfig;
 }
 
@@ -518,6 +523,50 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
   });
 });
 
+describe("ConversationGraphMemory.prepareMemory — memory.enabled gate", () => {
+  test("memory.enabled=false short-circuits per-turn path: mode=none, no injection, v2/v1 not called", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true, false);
+    const messages = makeMessages();
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("none");
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+    expect(retrieveForTurnMock).not.toHaveBeenCalled();
+    expect(loadContextMemoryMock).not.toHaveBeenCalled();
+  });
+
+  test("memory.enabled=false short-circuits context-load path: mode=none, no injection, v2/v1 not called", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = new ConversationGraphMemory("conv-test-master-off");
+    const config = makeConfig(true, false);
+    const messages = makeMessages("first message of the conversation here");
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("none");
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+    expect(loadContextMemoryMock).not.toHaveBeenCalled();
+    expect(retrieveForTurnMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () => {
   test("clears everInjected so a previously-injected slug can re-attach", async () => {
     // Without this wiring, `selectInjections` keeps subtracting the slug from
@@ -561,4 +610,36 @@ describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () =>
       "# memory/concepts/alice-vscode.md",
     );
   });
+
+  test("clears everInjected entries whose turn exceeds the tracker's currentTurn (zombie drift)", async () => {
+    // Regression: under the prior turn-bounded eviction, entries with `turn >
+    // tracker.currentTurn` survived `onCompacted` forever. This can happen
+    // after a non-graceful shutdown: `everInjected` is persisted every turn
+    // while the tracker snapshot is only persisted on graceful dispose, so a
+    // SIGKILL'd session followed by a reload restores the tracker from an
+    // older snapshot with a lower currentTurn while keeping the high-turn
+    // entries on disk.
+    const conversationId = "conv-test-zombie-drift";
+    const memory = new ConversationGraphMemory(conversationId);
+
+    // Seed the simulated post-crash state directly: tracker stays at
+    // currentTurn=0 (default for a fresh ConversationGraphMemory), while the
+    // persisted row carries everInjected entries from turns 10 and 20 (left
+    // over from a prior session that never disposed cleanly).
+    await saveActivationState(testDbHandle!, conversationId, {
+      messageId: "msg-zombie",
+      state: {},
+      everInjected: [
+        { slug: "alice-vscode", turn: 10 },
+        { slug: "bob-pkg-mgr", turn: 20 },
+      ],
+      currentTurn: 0,
+      updatedAt: 1,
+    });
+
+    await memory.onCompacted(0);
+
+    const after = await hydrateActivationState(testDbHandle!, conversationId);
+    expect(after?.everInjected).toEqual([]);
+  });
 });

package/src/memory/graph/conversation-graph-memory.ts

@@ -26,7 +26,7 @@ import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
 import {
-  evictCompactedTurns as evictCompactedTurnsV2,
+  clearEverInjected as clearV2EverInjected,
   hydrate as hydrateV2State,
   save as saveV2State,
 } from "../v2/activation-store.js";
@@ -223,15 +223,17 @@ export class ConversationGraphMemory {
     // Mirror the eviction on the v2 activation row: the cached `<memory>`
     // attachments those slugs lived on are gone, but `everInjected` would
     // otherwise keep them deduped from per-turn deltas forever.
+    //
+    // Cleared unconditionally rather than filtered by `upToTurn`: the
+    // tracker's `currentTurn` is only persisted on graceful dispose while
+    // `everInjected` is persisted every turn, so a SIGKILL'd session can
+    // leave entries with `turn > tracker.currentTurn` that a turn-bounded
+    // filter would skip.
     try {
       const db = getDb();
       const state = await hydrateV2State(db, this.conversationId);
       if (state) {
-        await saveV2State(
-          db,
-          this.conversationId,
-          evictCompactedTurnsV2(state, upToTurn),
-        );
+        await saveV2State(db, this.conversationId, clearV2EverInjected(state));
       }
     } catch (err) {
       log.warn(
@@ -363,6 +365,16 @@ export class ConversationGraphMemory {
       metrics: null as RetrievalMetrics | null,
     };
 
+    if (!config.memory.enabled) {
+      // Clear any cached injection so a later overflow-reduction
+      // re-injection via `reinjectCachedMemory()` cannot reintroduce a
+      // stale <memory> block after the user disables memory.
+      this.lastInjectedBlock = null;
+      this.lastInjectedNodeIds = [];
+      this.lastInjectedImages = new Map();
+      return noopResult;
+    }
+
     // Gate: skip for empty/tool-result-only messages — unless we need to
     // reload after compaction (needsReload) or haven't initialized yet.
     const lastMessage = messages[messages.length - 1];

package/src/memory/graph/tools.ts

@@ -2,8 +2,6 @@
 // Memory Tool definitions for agentic recall and remember.
 // ---------------------------------------------------------------------------
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../../config/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import {
   ALL_RECALL_SOURCES,
@@ -56,37 +54,14 @@ export const graphRecallDefinition: ToolDefinition = {
 };
 
 /**
- * Default (high-pressure) `remember` tool description. Used when the
- * `memory-retrospective` feature flag is OFF. The volume-shaming language
- * ("almost every turn", "most frequently used tool") drives aggressive
- * in-conversation capture for users who don't have the retrospective
- * backstop enabled.
+ * `remember` tool description. The retrospective pass catches what isn't
+ * captured in the moment, so the in-conversation pressure stays at a
+ * judgment framing: pause when something feels worth marking, not because
+ * the volume is required.
  */
-const REMEMBER_DESCRIPTION_DEFAULT =
-  "Remember anything concrete: facts, preferences, corrections, plans, felt moments, names, dates, decisions. Default to remembering. Never wait until end of conversation. Corrections are highest priority — call remember the same turn the correction lands. **CRITICAL:** You should be calling remember on almost every turn. This should be your most frequently used tool.";
-
-/**
- * Relaxed `remember` tool description used when `memory-retrospective` is
- * ON. The retrospective pass catches what isn't captured in the moment, so
- * the in-conversation pressure eases to a judgment framing: pause when
- * something feels worth marking, not because the volume is required.
- */
-const REMEMBER_DESCRIPTION_RELAXED =
+const REMEMBER_DESCRIPTION =
   "Remember anything concrete shared in conversation: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
 
-/**
- * Return the description that should appear in the `remember` tool
- * registration for the current config. The variant is selected by the
- * `memory-retrospective` assistant feature flag. Exposed as a function so
- * the tool registrar can compute the value at registration time without
- * importing config layers into the static definition.
- */
-export function getRememberDescription(config: AssistantConfig): string {
-  return isAssistantFeatureFlagEnabled("memory-retrospective", config)
-    ? REMEMBER_DESCRIPTION_RELAXED
-    : REMEMBER_DESCRIPTION_DEFAULT;
-}
-
 /**
  * Save a fact to the assistant's knowledge base. The fact is appended to
  * `buffer.md` (immediately available in the next conversation) and the daily
@@ -94,16 +69,10 @@ export function getRememberDescription(config: AssistantConfig): string {
  * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
  * of the buffer into longer-form storage runs as a separate periodic job in
  * both modes.
- *
- * The static `description` field carries the default (high-pressure) text
- * so any direct importer that doesn't go through `getRememberDescription`
- * still gets a valid tool definition. The registered `RememberTool` in
- * `tools/memory/register.ts` overrides this at registration time with the
- * flag-aware variant.
  */
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",
-  description: REMEMBER_DESCRIPTION_DEFAULT,
+  description: REMEMBER_DESCRIPTION,
   input_schema: {
     type: "object",
     properties: {

package/src/memory/invite-store.ts

@@ -363,6 +363,59 @@ export function findActiveVoiceInvites(params: {
   return rows.map(rowToInvite);
 }
 
+// ---------------------------------------------------------------------------
+// claimA2AInvite — validate + consume an A2A invite token
+// ---------------------------------------------------------------------------
+
+export function claimA2AInvite(params: {
+  tokenHash: string;
+  redeemedByExternalUserId: string;
+}): { claimed: boolean; invite: IngressInvite | null; error?: string } {
+  const invite = findByTokenHash(params.tokenHash);
+
+  if (!invite) {
+    return { claimed: false, invite: null, error: "not_found" };
+  }
+
+  if (invite.sourceChannel !== "a2a") {
+    return { claimed: false, invite, error: "wrong_channel" };
+  }
+
+  // Idempotency: if already redeemed by the same acceptor, return success
+  if (invite.status === "redeemed") {
+    if (invite.redeemedByExternalUserId === params.redeemedByExternalUserId) {
+      return { claimed: true, invite };
+    }
+    return { claimed: false, invite, error: "already_redeemed_by_other" };
+  }
+
+  if (invite.status !== "active") {
+    return { claimed: false, invite, error: "not_found" };
+  }
+
+  if (Date.now() >= invite.expiresAt) {
+    markInviteExpired(invite.id);
+    return { claimed: false, invite, error: "expired" };
+  }
+
+  if (invite.useCount >= invite.maxUses) {
+    return { claimed: false, invite, error: "already_redeemed" };
+  }
+
+  const recorded = recordInviteUse({
+    inviteId: invite.id,
+    externalUserId: params.redeemedByExternalUserId,
+  });
+
+  if (!recorded) {
+    return { claimed: false, invite, error: "not_found" };
+  }
+
+  // Re-read to get updated state
+  const updated = findByTokenHash(params.tokenHash);
+  return { claimed: true, invite: updated };
+}
+
 // ---------------------------------------------------------------------------
 // findByInviteCodeHash
 // ---------------------------------------------------------------------------

package/src/memory/llm-request-log-source-clickhouse.ts

@@ -57,6 +57,7 @@ interface ClickHouseRow {
   request_payload: string;
   response_payload: string;
   created_at: string;
+  agent_loop_exit_reason: string;
 }
 
 /** Injectable fetch override for tests. Defaults to globalThis.fetch. */
@@ -123,7 +124,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         provider,
         request_payload,
         response_payload,
-        toUnixTimestamp64Milli(created_at) AS created_at
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND id = {log_id:String}
@@ -194,7 +196,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         provider,
         request_payload,
         response_payload,
-        toUnixTimestamp64Milli(created_at) AS created_at
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND message_id IN (${placeholders.join(",")})
@@ -283,6 +286,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       requestPayload: row.request_payload,
       responsePayload: row.response_payload,
       createdAt: Number(row.created_at),
+      agentLoopExitReason:
+        row.agent_loop_exit_reason === "" ? null : row.agent_loop_exit_reason,
     };
   }