@vellumai/assistant 0.4.55 → 0.4.57

package/src/security/token-manager.ts

@@ -5,8 +5,23 @@
  * from the SQLite oauth-store (provider + app + connection rows). After a
  * successful refresh, writes tokens to new-format secure key paths and
  * updates the oauth_connection row.
+ *
+ * Token expiry checking, circuit breaker, refresh deduplication, and
+ * credential error classification are delegated to the shared
+ * `@vellumai/credential-storage` package.
  */
 
+import {
+  isCredentialError,
+  isTokenExpired,
+  oauthConnectionAccessTokenPath,
+  oauthConnectionRefreshTokenPath,
+  persistRefreshedTokens,
+  RefreshCircuitBreaker,
+  RefreshDeduplicator,
+  type SecureKeyBackend,
+} from "@vellumai/credential-storage";
+
 import {
   getApp,
   getConnection,
@@ -32,110 +47,20 @@ function recoveryHint(service: string): string {
   return ` Re-authorization required for ${shortName}. Do not present options or explain the error to the user.`;
 }
 
-/** Buffer before expiry to trigger proactive refresh (5 minutes). */
-const EXPIRY_BUFFER_MS = 5 * 60 * 1000;
-
-// ── Token refresh circuit breaker ────────────────────────────────────
-// Prevents retry storms when a provider persistently rejects refresh
-// attempts (e.g. revoked refresh token returning 401 repeatedly).
-// Per-service state: after FAILURE_THRESHOLD consecutive failures, stop
-// attempting refreshes for a cooldown period that doubles on each
-// successive trip (exponential backoff), capped at MAX_COOLDOWN_MS.
-// A successful refresh resets the breaker for that service.
-
-const REFRESH_FAILURE_THRESHOLD = 3;
-const INITIAL_COOLDOWN_MS = 30_000;
-const MAX_COOLDOWN_MS = 10 * 60 * 1000;
-
-interface RefreshBreakerState {
-  consecutiveFailures: number;
-  openedAt: number;
-  cooldownMs: number;
-}
-
-const refreshBreakers = new Map<string, RefreshBreakerState>();
-
-function isRefreshBreakerOpen(service: string): boolean {
-  const state = refreshBreakers.get(service);
-  if (!state || state.consecutiveFailures < REFRESH_FAILURE_THRESHOLD)
-    return false;
-  if (Date.now() - state.openedAt < state.cooldownMs) return true;
-  // Cooldown expired — transition to half-open: reset failure count so the
-  // next batch of failures must reach the threshold again to re-trip. The
-  // existing cooldownMs is preserved so re-tripping will escalate it.
-  state.consecutiveFailures = 0;
-  return false;
-}
-
-function recordRefreshSuccess(service: string): void {
-  if (refreshBreakers.has(service)) {
-    log.info(
-      { service },
-      "Token refresh circuit breaker closed — refresh succeeded",
-    );
-    refreshBreakers.delete(service);
-  }
-}
-
-function recordRefreshFailure(service: string): void {
-  const state = refreshBreakers.get(service);
-  if (!state) {
-    refreshBreakers.set(service, {
-      consecutiveFailures: 1,
-      openedAt: 0,
-      cooldownMs: INITIAL_COOLDOWN_MS,
-    });
-    return;
-  }
-  state.consecutiveFailures++;
-  if (state.consecutiveFailures >= REFRESH_FAILURE_THRESHOLD) {
-    // Only escalate cooldown on the exact failure that trips the breaker.
-    // Concurrent in-flight failures that arrive after the threshold is
-    // already crossed must not double the cooldown again.
-    if (
-      state.consecutiveFailures === REFRESH_FAILURE_THRESHOLD &&
-      state.openedAt > 0
-    ) {
-      state.cooldownMs = Math.min(state.cooldownMs * 2, MAX_COOLDOWN_MS);
-    }
-    state.openedAt = Date.now();
-    log.warn(
-      {
-        service,
-        consecutiveFailures: state.consecutiveFailures,
-        cooldownMs: state.cooldownMs,
-      },
-      "Token refresh circuit breaker opened — skipping refresh attempts until cooldown expires",
-    );
-  }
-}
-
-// ── Per-service refresh deduplication ─────────────────────────────────
-// When multiple concurrent `withValidToken` calls detect an expired or
-// 401-rejected token for the same service, only one actual refresh
-// attempt is made. Other callers join the in-flight promise.
-
-const inflightRefreshes = new Map<string, Promise<string>>();
+// ── Shared circuit breaker & deduplication instances ──────────────────
+// Backed by the portable primitives from @vellumai/credential-storage.
 
-function deduplicatedRefresh(service: string, connId: string): Promise<string> {
-  const existing = inflightRefreshes.get(connId);
-  if (existing) return existing;
-
-  const promise = doRefresh(service, connId).finally(() => {
-    inflightRefreshes.delete(connId);
-  });
-  inflightRefreshes.set(connId, promise);
-  return promise;
-}
+const circuitBreaker = new RefreshCircuitBreaker();
+const refreshDeduplicator = new RefreshDeduplicator();
 
 /** @internal Test-only: reset all circuit breaker state */
 export function _resetRefreshBreakers(): void {
-  refreshBreakers.clear();
+  circuitBreaker.clear();
 }
 
 /** @internal Test-only: reset in-flight refresh deduplication state */
 export function _resetInflightRefreshes(): void {
-  inflightRefreshes.clear();
+  refreshDeduplicator.clear();
 }
 
 export class TokenExpiredError extends Error {
@@ -150,13 +75,19 @@ export class TokenExpiredError extends Error {
   }
 }
 
-/**
- * Check whether a token is expired or will expire within the buffer window.
- */
-function isTokenExpired(expiresAt: number | null): boolean {
-  if (!expiresAt) return false;
-  return Date.now() >= expiresAt - EXPIRY_BUFFER_MS;
-}
+// ── Secure-key backend adapter ────────────────────────────────────────
+// Wraps the assistant's secure-key functions into the SecureKeyBackend
+// interface expected by @vellumai/credential-storage helpers.
+
+const secureKeyBackend: SecureKeyBackend = {
+  get: (key: string) => getSecureKeyAsync(key),
+  set: (key: string, value: string) => setSecureKeyAsync(key, value),
+  delete: async () => {
+    // Not needed in this module — refresh persistence only writes tokens.
+    return "not-found";
+  },
+  list: async () => [],
+};
 
 // ── Refresh config resolution ─────────────────────────────────────────
 
@@ -218,7 +149,7 @@ async function resolveRefreshConfig(
   const secret = await getSecureKeyAsync(app.clientSecretCredentialPath);
 
   const refreshToken = await getSecureKeyAsync(
-    `oauth_connection/${conn.id}/refresh_token`,
+    oauthConnectionRefreshTokenPath(conn.id),
   );
 
   const authMethod = provider.tokenEndpointAuthMethod as
@@ -261,8 +192,8 @@ async function doRefresh(service: string, connId: string): Promise<string> {
     );
   }
 
-  if (isRefreshBreakerOpen(connId)) {
-    const state = refreshBreakers.get(connId)!;
+  if (circuitBreaker.isOpen(connId)) {
+    const state = circuitBreaker.getState(connId)!;
     const remainingMs = state.cooldownMs - (Date.now() - state.openedAt);
     throw new TokenExpiredError(
       service,
@@ -283,7 +214,18 @@ async function doRefresh(service: string, connId: string): Promise<string> {
       authMethod,
     );
   } catch (err) {
-    recordRefreshFailure(connId);
+    circuitBreaker.recordFailure(connId);
+    if (circuitBreaker.isOpen(connId)) {
+      const state = circuitBreaker.getState(connId)!;
+      log.warn(
+        {
+          service,
+          consecutiveFailures: state.consecutiveFailures,
+          cooldownMs: state.cooldownMs,
+        },
+        "Token refresh circuit breaker opened — skipping refresh attempts until cooldown expires",
+      );
+    }
     if (isCredentialError(err)) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new TokenExpiredError(
@@ -297,45 +239,23 @@ async function doRefresh(service: string, connId: string): Promise<string> {
     throw err;
   }
 
-  // ----- Store refreshed access_token -----
-  if (
-    !(await setSecureKeyAsync(
-      `oauth_connection/${connId}/access_token`,
-      result.accessToken,
-    ))
-  ) {
+  // ----- Persist refreshed tokens via shared helper -----
+  let persisted;
+  try {
+    persisted = await persistRefreshedTokens(secureKeyBackend, connId, result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
     throw new TokenExpiredError(
       service,
-      `Failed to store refreshed access token for "${service}".`,
+      `Failed to store refreshed access token for "${service}": ${msg}`,
     );
   }
 
-  if (result.refreshToken) {
-    if (
-      !(await setSecureKeyAsync(
-        `oauth_connection/${connId}/refresh_token`,
-        result.refreshToken,
-      ))
-    ) {
-      throw new TokenExpiredError(
-        service,
-        `Failed to store refreshed refresh token for "${service}".`,
-      );
-    }
-  }
-
   // Update oauth_connection row with new expiry.
-  // Use null to explicitly clear a stale expiresAt when the provider omits
-  // expires_in (or returns 0), so isTokenExpired won't keep forcing refreshes.
-  const expiresAt =
-    result.expiresIn != null && result.expiresIn > 0
-      ? Date.now() + result.expiresIn * 1000
-      : null;
-
   try {
     updateConnection(connId, {
-      expiresAt,
-      hasRefreshToken: !!result.refreshToken,
+      expiresAt: persisted.expiresAt,
+      hasRefreshToken: persisted.hasRefreshToken,
     });
   } catch (err) {
     log.warn(
@@ -344,9 +264,9 @@ async function doRefresh(service: string, connId: string): Promise<string> {
     );
   }
 
-  recordRefreshSuccess(connId);
+  circuitBreaker.recordSuccess(connId);
   log.info({ service }, "OAuth2 access token refreshed successfully");
-  return result.accessToken;
+  return persisted.accessToken;
 }
 
 /**
@@ -370,7 +290,7 @@ export async function withValidToken<T>(
       ? getConnection(opts.connectionId)
       : getConnectionByProvider(service, opts);
   let token = conn
-    ? await getSecureKeyAsync(`oauth_connection/${conn.id}/access_token`)
+    ? await getSecureKeyAsync(oauthConnectionAccessTokenPath(conn.id))
     : undefined;
   if (!token || !conn) {
     throw new TokenExpiredError(
@@ -381,14 +301,18 @@ export async function withValidToken<T>(
 
   // Proactively refresh if expired or about to expire.
   if (isTokenExpired(conn.expiresAt)) {
-    token = await deduplicatedRefresh(service, conn.id);
+    token = await refreshDeduplicator.deduplicate(conn.id, () =>
+      doRefresh(service, conn.id),
+    );
   }
 
   try {
     return await callback(token);
   } catch (err: unknown) {
     if (is401Error(err)) {
-      token = await deduplicatedRefresh(service, conn.id);
+      token = await refreshDeduplicator.deduplicate(conn.id, () =>
+        doRefresh(service, conn.id),
+      );
       return callback(token);
     }
     throw err;
@@ -407,27 +331,3 @@ function is401Error(err: unknown): boolean {
   }
   return false;
 }
-
-/**
- * Distinguish credential-specific refresh failures (which need reauthorization)
- * from transient errors (network timeouts, 5xx) that can be retried.
- *
- * refreshOAuth2Token() throws Error with messages like:
- *   "OAuth2 token refresh failed (HTTP 401: invalid_client)"
- *   "OAuth2 token refresh failed (HTTP 400: invalid_grant)"
- *   "OAuth2 token refresh failed (HTTP 500)"
- *
- * Credential errors: 400 with invalid_grant or invalid_client, 401, 403.
- * Everything else (5xx, network errors, non-credential 400s) is transient.
- */
-function isCredentialError(err: unknown): boolean {
-  if (!(err instanceof Error)) return false;
-  const msg = err.message;
-  // 401/403 are always credential errors
-  if (/HTTP\s+40[13]\b/.test(msg)) return true;
-  // 400 with invalid_grant means the refresh token is revoked/expired;
-  // invalid_client means client credentials are bad/rotated
-  if (/HTTP\s+400\b/.test(msg) && /invalid_grant|invalid_client/.test(msg))
-    return true;
-  return false;
-}

package/src/sequence/engine.ts

@@ -19,7 +19,7 @@ import {
   getEnrollment,
   getSequence,
   rescheduleEnrollment,
-  updateEnrollmentThreadId,
+  updateEnrollmentConversationId,
 } from "./store.js";
 import type { Sequence, SequenceEnrollment, SequenceStep } from "./types.js";
 
@@ -166,13 +166,13 @@ async function processEnrollment(
   await processMessage(conversation.id, prompt);
 
   // Try to extract the email thread ID from conversation tool results so
-  // subsequent steps can reply in the same thread.
-  const threadId =
+  // subsequent steps can reply in the same conversation.
+  const extractedConversationId =
     extractThreadIdFromConversation(conversation.id) ?? undefined;
-  if (threadId) {
+  if (extractedConversationId) {
     log.info(
-      { enrollmentId: enrollment.id, threadId },
-      "Captured thread ID from step execution",
+      { enrollmentId: enrollment.id, conversationId: extractedConversationId },
+      "Captured conversation ID from step execution",
     );
   }
 
@@ -181,7 +181,8 @@ async function processEnrollment(
   // null so it won't be re-claimed. The approval/send flow is responsible
   // for advancing the enrollment once the draft is approved.
   if (step.requireApproval) {
-    if (threadId) updateEnrollmentThreadId(enrollment.id, threadId);
+    if (extractedConversationId)
+      updateEnrollmentConversationId(enrollment.id, extractedConversationId);
     log.info(
       {
         enrollmentId: enrollment.id,
@@ -203,7 +204,7 @@ async function processEnrollment(
   const nextStepIndex = enrollment.currentStep + 1;
   if (nextStepIndex >= sequence.steps.length) {
     // This was the final step
-    advanceEnrollment(enrollment.id, threadId, null);
+    advanceEnrollment(enrollment.id, extractedConversationId, null);
     recordEvent(sequence.id, enrollment.id, "complete", step.index);
     exitEnrollment(enrollment.id, "completed");
     log.info(
@@ -213,7 +214,7 @@ async function processEnrollment(
   } else {
     const nextStep = sequence.steps[nextStepIndex];
     const nextStepAt = Date.now() + nextStep.delaySeconds * 1000;
-    advanceEnrollment(enrollment.id, threadId, nextStepAt);
+    advanceEnrollment(enrollment.id, extractedConversationId, nextStepAt);
     log.info(
       {
         enrollmentId: enrollment.id,
@@ -264,9 +265,9 @@ function buildStepPrompt(
     parts.push(`Send an email with subject "${step.subjectTemplate}".`);
   }
 
-  if (step.replyToThread && enrollment.threadId) {
+  if (step.replyInSameConversation && enrollment.conversationId) {
     parts.push(
-      `Reply in the existing thread (thread ID: ${enrollment.threadId}).`,
+      `Reply in the existing conversation (conversation ID: ${enrollment.conversationId}).`,
     );
   }
 

package/src/sequence/reply-matcher.ts

@@ -4,7 +4,7 @@
  *
  * Called from the watcher engine after new events are stored.
  * Matches by sender email against active enrollment contact_email
- * AND thread_id — both must match for a reply to trigger an exit.
+ * AND conversationId — both must match for a reply to trigger an exit.
  */
 
 import { getLogger } from "../util/logger.js";
@@ -54,7 +54,7 @@ export interface ReplyMatchResult {
   contactEmail: string;
   sequenceId: string;
   sequenceName: string;
-  threadId?: string;
+  conversationId?: string;
 }
 
 /**
@@ -77,15 +77,18 @@ export function checkForSequenceReplies(
       const seq = getSequence(enrollment.sequenceId);
       if (!seq || !seq.exitOnReply) continue;
 
-      // Only match when the enrollment has a thread ID and it matches the
-      // incoming payload. Enrollments that haven't sent their first email
-      // yet (threadId is null) are not eligible for reply-based exit —
-      // otherwise any unrelated inbound email from the contact would
-      // prematurely kill the enrollment.
-      const threadMatch =
-        enrollment.threadId != null && enrollment.threadId === payload.threadId;
+      // Only match when the enrollment has a conversation ID and it matches
+      // the incoming payload's thread ID. Enrollments that haven't sent their
+      // first email yet (conversationId is null) are not eligible for
+      // reply-based exit — otherwise any unrelated inbound email from the
+      // contact would prematurely kill the enrollment.
+      // Note: payload.threadId is the external provider's thread identifier
+      // (e.g. Gmail API thread ID) which maps to enrollment.conversationId.
+      const conversationMatch =
+        enrollment.conversationId != null &&
+        enrollment.conversationId === payload.threadId;
 
-      if (!threadMatch) continue;
+      if (!conversationMatch) continue;
 
       recordEvent(
         enrollment.sequenceId,
@@ -94,7 +97,7 @@ export function checkForSequenceReplies(
         enrollment.currentStep,
         {
           senderEmail,
-          threadId: payload.threadId,
+          conversationId: payload.threadId,
         },
       );
       exitEnrollment(enrollment.id, "replied");
@@ -103,7 +106,7 @@ export function checkForSequenceReplies(
         {
           enrollmentId: enrollment.id,
           senderEmail,
-          threadId: payload.threadId,
+          conversationId: payload.threadId,
         },
         "Sequence enrollment exited on reply",
       );
@@ -113,7 +116,7 @@ export function checkForSequenceReplies(
         contactEmail: enrollment.contactEmail,
         sequenceId: enrollment.sequenceId,
         sequenceName: seq.name,
-        threadId: payload.threadId,
+        conversationId: payload.threadId,
       });
     }
   }

package/src/sequence/store.ts

@@ -58,7 +58,7 @@ const parseEnrollmentRow = createRowMapper<
   contactName: "contactName",
   currentStep: "currentStep",
   status: { from: "status", transform: cast<SequenceEnrollment["status"]>() },
-  threadId: "threadId",
+  conversationId: "conversationId",
   nextStepAt: "nextStepAt",
   context: {
     from: "context",
@@ -168,7 +168,7 @@ export function enrollContact(input: EnrollContactInput): SequenceEnrollment {
     contactName: input.contactName ?? null,
     currentStep: 0,
     status: "active" as const,
-    threadId: null,
+    conversationId: null,
     nextStepAt,
     context: input.context ? JSON.stringify(input.context) : null,
     createdAt: now,
@@ -267,7 +267,7 @@ export function claimDueEnrollments(
 
 export function advanceEnrollment(
   id: string,
-  threadId?: string,
+  conversationId?: string,
   nextStepAt?: number | null,
 ): SequenceEnrollment | undefined {
   const db = getDb();
@@ -286,7 +286,7 @@ export function advanceEnrollment(
   if (!current) return undefined;
 
   updates.currentStep = current.currentStep + 1;
-  if (threadId !== undefined) updates.threadId = threadId;
+  if (conversationId !== undefined) updates.conversationId = conversationId;
   if (nextStepAt !== undefined) updates.nextStepAt = nextStepAt;
 
   db.update(sequenceEnrollments)
@@ -367,11 +367,14 @@ export function rescheduleEnrollment(id: string, nextStepAt: number): void {
     .run();
 }
 
-/** Persist a thread ID on an enrollment without advancing the step counter. */
-export function updateEnrollmentThreadId(id: string, threadId: string): void {
+/** Persist a conversation ID on an enrollment without advancing the step counter. */
+export function updateEnrollmentConversationId(
+  id: string,
+  conversationId: string,
+): void {
   const db = getDb();
   db.update(sequenceEnrollments)
-    .set({ threadId, updatedAt: Date.now() })
+    .set({ conversationId, updatedAt: Date.now() })
     .where(eq(sequenceEnrollments.id, id))
     .run();
 }

package/src/sequence/types.ts

@@ -18,7 +18,7 @@ export interface SequenceStep {
   delaySeconds: number; // delay from previous step (0 for first step)
   subjectTemplate: string; // subject line template
   bodyPrompt: string; // prompt for the assistant to generate body
-  replyToThread: boolean; // whether to reply in the same thread as step 1
+  replyInSameConversation: boolean; // whether to reply in the same conversation as step 1
   requireApproval: boolean; // draft-first, require human approval before send
 }
 
@@ -41,7 +41,7 @@ export interface SequenceEnrollment {
   contactName: string | null;
   currentStep: number; // index of the next step to send (0-based)
   status: EnrollmentStatus;
-  threadId: string | null; // messaging thread ID (set after first send)
+  conversationId: string | null; // messaging conversation ID (set after first send)
   nextStepAt: number | null; // epoch ms — when the next step is due
   context: Record<string, unknown> | null; // per-enrollment personalization context
   createdAt: number;

package/src/signals/bash.ts

@@ -21,7 +21,7 @@ import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getLogger } from "../util/logger.js";
-import { getWorkspaceDir } from "../util/platform.js";
+import { getSignalsDir, getWorkspaceDir } from "../util/platform.js";
 
 const log = getLogger("signal:bash");
 
@@ -51,7 +51,7 @@ interface BashSignalResult {
 function writeResult(requestId: string, result: BashSignalResult): void {
   try {
     writeFileSync(
-      join(getWorkspaceDir(), "signals", `bash.${requestId}.result`),
+      join(getSignalsDir(), `bash.${requestId}.result`),
       JSON.stringify(result),
     );
   } catch (err) {
@@ -80,13 +80,13 @@ export function handleBashSignal(filename: string): void {
         exitCode: null,
         timedOut: false,
         error:
-          "Bash signals are disabled. Start the assistant with VELLUM_DEBUG=1 to enable.",
+          "Bash signals are disabled. The running assistant process must have been started with VELLUM_DEBUG=1 (setting it on the CLI command alone is not enough). Restart the assistant with: VELLUM_DEBUG=1 assistant start",
       });
     }
     return;
   }
 
-  const signalPath = join(getWorkspaceDir(), "signals", filename);
+  const signalPath = join(getSignalsDir(), filename);
   let raw: string;
   try {
     raw = readFileSync(signalPath, "utf-8");

package/src/signals/cancel.ts

@@ -4,9 +4,9 @@
  * The built-in CLI writes JSON to `signals/cancel` instead of making an
  * HTTP POST to `/v1/conversations/:id/cancel`. The daemon's ConfigWatcher
  * detects the file change and invokes {@link handleCancelSignal}, which
- * reads the payload and aborts the target session.
+ * reads the payload and aborts the target conversation.
  *
- * Because the signal handler needs access to the daemon's session map, the
+ * Because the signal handler needs access to the daemon's conversation map, the
  * daemon registers a callback at startup via {@link registerCancelCallback}.
  */
 
@@ -14,19 +14,19 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getLogger } from "../util/logger.js";
-import { getWorkspaceDir } from "../util/platform.js";
+import { getSignalsDir } from "../util/platform.js";
 
 const log = getLogger("signal:cancel");
 
 // ── Daemon callback registry ─────────────────────────────────────────
 
-type CancelCallback = (sessionId: string) => boolean;
+type CancelCallback = (conversationId: string) => boolean;
 
 let _cancelGeneration: CancelCallback | null = null;
 
 /**
  * Register the cancel-generation callback. Called once by the daemon
- * server at startup so the signal handler can reach the session map.
+ * server at startup so the signal handler can reach the conversation map.
  */
 export function registerCancelCallback(cb: CancelCallback): void {
   _cancelGeneration = cb;
@@ -35,20 +35,17 @@ export function registerCancelCallback(cb: CancelCallback): void {
 // ── Signal handler ───────────────────────────────────────────────────
 
 /**
- * Read the `signals/cancel` file and abort the target session.
+ * Read the `signals/cancel` file and abort the target conversation.
  * Called by ConfigWatcher when the signal file is written or modified.
  */
 export function handleCancelSignal(): void {
   try {
-    const content = readFileSync(
-      join(getWorkspaceDir(), "signals", "cancel"),
-      "utf-8",
-    );
-    const parsed = JSON.parse(content) as { sessionId?: string };
-    const { sessionId } = parsed;
+    const content = readFileSync(join(getSignalsDir(), "cancel"), "utf-8");
+    const parsed = JSON.parse(content) as { conversationId?: string };
+    const { conversationId } = parsed;
 
-    if (!sessionId || typeof sessionId !== "string") {
-      log.warn("Cancel signal missing sessionId");
+    if (!conversationId || typeof conversationId !== "string") {
+      log.warn("Cancel signal missing conversationId");
       return;
     }
 
@@ -57,11 +54,11 @@ export function handleCancelSignal(): void {
       return;
     }
 
-    const found = _cancelGeneration(sessionId);
+    const found = _cancelGeneration(conversationId);
     if (found) {
-      log.info({ sessionId }, "Generation cancelled via signal file");
+      log.info({ conversationId }, "Generation cancelled via signal file");
     } else {
-      log.warn({ sessionId }, "No active session for cancel signal");
+      log.warn({ conversationId }, "No active conversation for cancel signal");
     }
   } catch (err) {
     log.error({ err }, "Failed to handle cancel signal");