@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/memory/{compaction-log-writer-clickhouse.ts → compaction-log-store-clickhouse.ts}

@@ -1,5 +1,5 @@
 /**
- * ClickHouse compaction log writer.
+ * ClickHouse compaction log store.
  *
  * Consumes the agent loop's compaction start/end event pair
  * (`context_compacting` / `compaction_completed`, correlated by
@@ -10,8 +10,12 @@
  *
  * The table is event-sourced rather than upserted: a `start` row records
  * that an attempt began (so attempts that never complete — pipeline throw,
- * turn abort — are still visible), and an `end` row carries the full
- * `ContextWindowResult`. Consumers pair rows by `compaction_id`.
+ * turn abort — are still visible), and an `end` row carries the
+ * `ContextWindowResult` fields unnested on the event. Consumers pair rows
+ * by `compaction_id`.
+ *
+ * The store also serves reads: the compaction-trail route pairs the rows
+ * back into per-attempt events via `getEventsBetween`.
  *
  * Writes are strictly best-effort: every entry point swallows and logs
  * failures so a ClickHouse outage can never abort a turn. URL and password
@@ -27,7 +31,7 @@ import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
 
-const log = getLogger("compaction-log-writer");
+const log = getLogger("compaction-log-store");
 
 export type CompactionStartEvent = Extract<
   AgentEvent,
@@ -58,7 +62,7 @@ interface CompactionLogRow {
   finished_at: number;
   duration_ms: number;
   pre_message_count: number;
-  basis_message_count: number;
+  result_message_count: number;
   compacted: number;
   previous_estimated_input_tokens: number;
   estimated_input_tokens: number;
@@ -87,10 +91,47 @@ async function readCredentialOrNull(
   return value ?? null;
 }
 
+/**
+ * One compaction attempt, reconstructed from its start/end row pair.
+ * `null` means the value isn't known — either the field belongs to the
+ * other phase's row, the attempt never completed, or the stored value was
+ * the column's sentinel.
+ */
+export interface CompactionLogEvent {
+  compactionId: string;
+  requestId: string;
+  trigger: string;
+  startedAt: number;
+  finishedAt: number | null;
+  durationMs: number | null;
+  preMessageCount: number | null;
+  resultMessageCount: number | null;
+  compacted: boolean | null;
+  previousEstimatedInputTokens: number | null;
+  estimatedInputTokens: number | null;
+  maxInputTokens: number | null;
+  thresholdTokens: number | null;
+  compactedMessages: number | null;
+  compactedPersistedMessages: number | null;
+  preservedTailMessages: number | null;
+  summaryCalls: number | null;
+  summaryInputTokens: number | null;
+  summaryOutputTokens: number | null;
+  summaryModel: string | null;
+  summaryFailed: boolean | null;
+  reason: string | null;
+  exhausted: boolean | null;
+  injectionMode: string | null;
+  autoCompressApplied: boolean | null;
+  summaryText: string | null;
+  /** True when the end row exists — the attempt ran to completion. */
+  completed: boolean;
+}
+
 /** Injectable fetch override for tests. Defaults to globalThis.fetch. */
 export type CompactionLogFetch = typeof fetch;
 
-export interface ClickHouseCompactionLogWriterDeps {
+export interface ClickHouseCompactionLogStoreDeps {
   /** Override the credential read for `clickhouse:url`. */
   resolveUrl?: () => Promise<string | null>;
   /** Override the credential read for `clickhouse:password`. */
@@ -101,7 +142,7 @@ export interface ClickHouseCompactionLogWriterDeps {
   fetchImpl?: CompactionLogFetch;
 }
 
-export class ClickHouseCompactionLogWriter {
+export class ClickHouseCompactionLogStore {
   private cachedUrl: string | null = null;
   private cachedPassword: string | null = null;
   private cachedAssistantId: string | null = null;
@@ -114,7 +155,7 @@ export class ClickHouseCompactionLogWriter {
 
   constructor(
     private readonly config: CompactionLogsClickHouseConfig,
-    deps: ClickHouseCompactionLogWriterDeps = {},
+    deps: ClickHouseCompactionLogStoreDeps = {},
   ) {
     this.resolveUrl =
       deps.resolveUrl ?? (() => readCredentialOrNull("clickhouse", "url"));
@@ -142,35 +183,105 @@ export class ClickHouseCompactionLogWriter {
     conversationId: string,
     event: CompactionEndEvent,
   ): Promise<void> {
-    const r = event.result;
     await this.insert({
       ...emptyRow(await this.assistantId(), conversationId, event),
       phase: "end",
       finished_at: event.finishedAt,
       duration_ms: event.finishedAt - event.startedAt,
-      basis_message_count: event.messages.length,
-      compacted: r.compacted ? 1 : 0,
-      previous_estimated_input_tokens: r.previousEstimatedInputTokens,
-      estimated_input_tokens: r.estimatedInputTokens,
-      max_input_tokens: r.maxInputTokens,
-      threshold_tokens: r.thresholdTokens,
-      compacted_messages: r.compactedMessages,
-      compacted_persisted_messages: r.compactedPersistedMessages,
-      preserved_tail_messages: r.preservedTailMessages ?? -1,
-      summary_calls: r.summaryCalls,
-      summary_input_tokens: r.summaryInputTokens,
-      summary_output_tokens: r.summaryOutputTokens,
-      summary_model: r.summaryModel,
+      result_message_count: event.messages.length,
+      compacted: event.compacted ? 1 : 0,
+      previous_estimated_input_tokens: event.previousEstimatedInputTokens,
+      estimated_input_tokens: event.estimatedInputTokens,
+      max_input_tokens: event.maxInputTokens,
+      threshold_tokens: event.thresholdTokens,
+      compacted_messages: event.compactedMessages,
+      compacted_persisted_messages: event.compactedPersistedMessages,
+      preserved_tail_messages: event.preservedTailMessages ?? -1,
+      summary_calls: event.summaryCalls,
+      summary_input_tokens: event.summaryInputTokens,
+      summary_output_tokens: event.summaryOutputTokens,
+      summary_model: event.summaryModel,
       summary_failed:
-        r.summaryFailed === undefined ? -1 : r.summaryFailed ? 1 : 0,
-      reason: r.reason ?? "",
-      exhausted: r.exhausted ? 1 : 0,
-      injection_mode: r.injectionMode ?? "",
-      auto_compress_applied: r.autoCompressApplied ? 1 : 0,
-      summary_text: r.summaryText.slice(0, SUMMARY_TEXT_MAX_CHARS),
+        event.summaryFailed === undefined ? -1 : event.summaryFailed ? 1 : 0,
+      reason: event.reason ?? "",
+      exhausted: event.exhausted ? 1 : 0,
+      injection_mode: event.injectionMode ?? "",
+      auto_compress_applied: event.autoCompressApplied ? 1 : 0,
+      summary_text: event.summaryText.slice(0, SUMMARY_TEXT_MAX_CHARS),
     });
   }
 
+  /**
+   * Read all compaction attempts whose `started_at` falls strictly inside
+   * the given window, pairing start/end rows by `compaction_id`. Mirrors
+   * the strict `>` / `<` predicate contract of
+   * `getCompactionLogsBetween` on the llm-request-log sources, so the
+   * route can apply the same ±1ms boundary shifts to both.
+   */
+  async getEventsBetween(
+    conversationId: string,
+    afterStartedAt: number | null,
+    beforeStartedAt: number,
+  ): Promise<CompactionLogEvent[]> {
+    const params: Record<string, string> = {
+      assistant_id: await this.assistantId(),
+      conversation_id: conversationId,
+      before_started_at: String(beforeStartedAt),
+    };
+    // Type-bound parameter slots referenced in the SQL but unbound at exec
+    // time return a server error, so the floor predicate is only templated
+    // in when the caller has one.
+    let afterPredicate = "";
+    if (afterStartedAt !== null) {
+      params.after_started_at = String(afterStartedAt);
+      afterPredicate =
+        " AND started_at > fromUnixTimestamp64Milli({after_started_at:Int64})";
+    }
+    const sql = `SELECT
+        compaction_id,
+        request_id,
+        phase,
+        trigger,
+        toUnixTimestamp64Milli(started_at) AS started_at,
+        toUnixTimestamp64Milli(finished_at) AS finished_at,
+        duration_ms,
+        pre_message_count,
+        result_message_count,
+        compacted,
+        previous_estimated_input_tokens,
+        estimated_input_tokens,
+        max_input_tokens,
+        threshold_tokens,
+        compacted_messages,
+        compacted_persisted_messages,
+        preserved_tail_messages,
+        summary_calls,
+        summary_input_tokens,
+        summary_output_tokens,
+        summary_model,
+        summary_failed,
+        reason,
+        exhausted,
+        injection_mode,
+        auto_compress_applied,
+        summary_text
+      FROM ${this.tableRef()}
+      WHERE assistant_id = {assistant_id:String}
+        AND conversation_id = {conversation_id:String}
+        AND started_at < fromUnixTimestamp64Milli({before_started_at:Int64})${afterPredicate}
+      ORDER BY started_at ASC, created_at ASC
+      LIMIT 1 BY compaction_id, phase
+      FORMAT JSONEachRow`;
+    const text = await this.exec(sql, undefined, params);
+    const rows: Record<string, unknown>[] = [];
+    for (const line of text.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      rows.push(JSON.parse(trimmed) as Record<string, unknown>);
+    }
+    return pairRowsIntoEvents(rows);
+  }
+
   private async insert(row: CompactionLogRow): Promise<void> {
     await this.ensureTable();
     await this.exec(
@@ -198,7 +309,7 @@ export class ClickHouseCompactionLogWriter {
           finished_at DateTime64(3),
           duration_ms Int64,
           pre_message_count Int64,
-          basis_message_count Int64,
+          result_message_count Int64,
           compacted UInt8,
           previous_estimated_input_tokens Int64,
           estimated_input_tokens Int64,
@@ -220,10 +331,13 @@ export class ClickHouseCompactionLogWriter {
           created_at DateTime64(3) DEFAULT now64(3)
         ) ENGINE = MergeTree
         ORDER BY (assistant_id, conversation_id, started_at, compaction_id)`,
-      ).catch((err: unknown) => {
-        this.ensureTablePromise = null;
-        throw err;
-      });
+      ).then(
+        () => undefined,
+        (err: unknown) => {
+          this.ensureTablePromise = null;
+          throw err;
+        },
+      );
     }
     return this.ensureTablePromise;
   }
@@ -235,7 +349,11 @@ export class ClickHouseCompactionLogWriter {
     return `\`${this.config.table.replace(/`/g, "``")}\``;
   }
 
-  private async exec(sql: string, body?: string): Promise<void> {
+  private async exec(
+    sql: string,
+    body?: string,
+    params?: Record<string, string>,
+  ): Promise<string> {
     const baseUrl = await this.url();
     const password = await this.password();
 
@@ -248,6 +366,9 @@ export class ClickHouseCompactionLogWriter {
       );
     }
     target.searchParams.set("database", this.config.database);
+    for (const [k, v] of Object.entries(params ?? {})) {
+      target.searchParams.set(`param_${k}`, v);
+    }
     // For INSERTs the statement goes in the `query` param and the row data
     // in the body; DDL ships as the body itself.
     // Integer timestamps land correctly in DateTime64(3) columns: ClickHouse
@@ -270,11 +391,10 @@ export class ClickHouseCompactionLogWriter {
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new Error(
-        `ClickHouse compaction-log write failed (HTTP ${res.status}): ${text.slice(0, 500)}`,
+        `ClickHouse compaction-log request failed (HTTP ${res.status}): ${text.slice(0, 500)}`,
       );
     }
-    // Drain the body so the connection can be reused.
-    await res.text().catch(() => "");
+    return res.text();
   }
 
   private async assistantId(): Promise<string> {
@@ -331,7 +451,7 @@ function emptyRow(
     finished_at: 0,
     duration_ms: -1,
     pre_message_count: -1,
-    basis_message_count: -1,
+    result_message_count: -1,
     compacted: 0,
     previous_estimated_input_tokens: -1,
     estimated_input_tokens: -1,
@@ -353,32 +473,121 @@ function emptyRow(
   };
 }
 
+function num(value: unknown): number {
+  return typeof value === "number" ? value : Number(value);
+}
+
+/** Map the `-1` "unknown count" column sentinel back to null. */
+function countOrNull(value: unknown): number | null {
+  const n = num(value);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+
+/** Map the `''` "not set" string column sentinel back to null. */
+function strOrNull(value: unknown): string | null {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
 /**
- * Writer cache keyed by the serialized connection config so config edits
+ * Pair raw start/end rows by `compaction_id` into per-attempt events.
+ * Start-only pairs (the attempt never completed) surface with end-phase
+ * fields null and `completed: false`.
+ */
+function pairRowsIntoEvents(
+  rows: Record<string, unknown>[],
+): CompactionLogEvent[] {
+  const byId = new Map<
+    string,
+    { start?: Record<string, unknown>; end?: Record<string, unknown> }
+  >();
+  for (const row of rows) {
+    const id = String(row.compaction_id);
+    const pair = byId.get(id) ?? {};
+    if (row.phase === "end") pair.end = row;
+    else pair.start = row;
+    byId.set(id, pair);
+  }
+  const events: CompactionLogEvent[] = [];
+  for (const [compactionId, { start, end }] of byId) {
+    const base = end ?? start;
+    if (!base) continue;
+    events.push({
+      compactionId,
+      requestId: String(base.request_id ?? ""),
+      trigger: String(base.trigger ?? ""),
+      startedAt: num(base.started_at),
+      finishedAt: end ? num(end.finished_at) : null,
+      durationMs: end ? countOrNull(end.duration_ms) : null,
+      preMessageCount: start ? countOrNull(start.pre_message_count) : null,
+      resultMessageCount: end ? countOrNull(end.result_message_count) : null,
+      compacted: end ? num(end.compacted) === 1 : null,
+      previousEstimatedInputTokens: end
+        ? countOrNull(end.previous_estimated_input_tokens)
+        : null,
+      estimatedInputTokens: end
+        ? countOrNull(end.estimated_input_tokens)
+        : null,
+      maxInputTokens: end ? countOrNull(end.max_input_tokens) : null,
+      thresholdTokens: end ? countOrNull(end.threshold_tokens) : null,
+      compactedMessages: end ? countOrNull(end.compacted_messages) : null,
+      compactedPersistedMessages: end
+        ? countOrNull(end.compacted_persisted_messages)
+        : null,
+      preservedTailMessages: end
+        ? countOrNull(end.preserved_tail_messages)
+        : null,
+      summaryCalls: end ? countOrNull(end.summary_calls) : null,
+      summaryInputTokens: end ? countOrNull(end.summary_input_tokens) : null,
+      summaryOutputTokens: end ? countOrNull(end.summary_output_tokens) : null,
+      summaryModel: end ? strOrNull(end.summary_model) : null,
+      summaryFailed:
+        end && num(end.summary_failed) !== -1
+          ? num(end.summary_failed) === 1
+          : null,
+      reason: end ? strOrNull(end.reason) : null,
+      exhausted: end ? num(end.exhausted) === 1 : null,
+      injectionMode: end ? strOrNull(end.injection_mode) : null,
+      autoCompressApplied: end ? num(end.auto_compress_applied) === 1 : null,
+      summaryText: end ? strOrNull(end.summary_text) : null,
+      completed: end !== undefined,
+    });
+  }
+  return events.sort(
+    (a, b) =>
+      a.startedAt - b.startedAt || a.compactionId.localeCompare(b.compactionId),
+  );
+}
+
+/**
+ * Store cache keyed by the serialized connection config so config edits
  * take effect on the next event without restarting, while steady-state
  * writes reuse one instance (and its cached credentials / ensured table).
  */
-let cachedWriter: {
+let cachedStore: {
   key: string;
-  writer: ClickHouseCompactionLogWriter;
+  store: ClickHouseCompactionLogStore;
 } | null = null;
 
-function getWriter(): ClickHouseCompactionLogWriter | null {
+/**
+ * Resolve the configured ClickHouse compaction log store, or null when
+ * `compactionLogs.destination` is not `"clickhouse"`.
+ */
+export function getCompactionLogStore(): ClickHouseCompactionLogStore | null {
   const cfg = getConfig().compactionLogs;
   if (!cfg || cfg.destination !== "clickhouse") return null;
   const key = JSON.stringify(cfg.clickhouse);
-  if (!cachedWriter || cachedWriter.key !== key) {
-    cachedWriter = {
+  if (!cachedStore || cachedStore.key !== key) {
+    cachedStore = {
       key,
-      writer: new ClickHouseCompactionLogWriter(cfg.clickhouse),
+      store: new ClickHouseCompactionLogStore(cfg.clickhouse),
     };
   }
-  return cachedWriter.writer;
+  return cachedStore.store;
 }
 
-/** Test hook: drop the memoized writer so config/dep changes are picked up. */
-export function resetCompactionLogWriterForTests(): void {
-  cachedWriter = null;
+/** Test hook: drop the memoized store so config/dep changes are picked up. */
+export function resetCompactionLogStoreForTests(): void {
+  cachedStore = null;
 }
 
 /**
@@ -389,9 +598,9 @@ export function recordCompactionStartBestEffort(
   conversationId: string,
   event: CompactionStartEvent,
 ): void {
-  const writer = getWriter();
-  if (!writer) return;
-  writer.writeStart(conversationId, event).catch((err: unknown) => {
+  const store = getCompactionLogStore();
+  if (!store) return;
+  store.writeStart(conversationId, event).catch((err: unknown) => {
     log.warn(
       { err, conversationId, compactionId: event.compactionId },
       "Failed to write compaction start log (non-fatal)",
@@ -407,9 +616,9 @@ export function recordCompactionEndBestEffort(
   conversationId: string,
   event: CompactionEndEvent,
 ): void {
-  const writer = getWriter();
-  if (!writer) return;
-  writer.writeEnd(conversationId, event).catch((err: unknown) => {
+  const store = getCompactionLogStore();
+  if (!store) return;
+  store.writeEnd(conversationId, event).catch((err: unknown) => {
     log.warn(
       { err, conversationId, compactionId: event.compactionId },
       "Failed to write compaction end log (non-fatal)",

package/src/memory/conversation-attention-store.ts

@@ -24,6 +24,7 @@ export type SignalType =
   | "macos_notification_view"
   | "macos_conversation_opened"
   | "ios_conversation_opened"
+  | "web_bulk_mark_read"
   | "telegram_inbound_message"
   | "telegram_callback"
   | "slack_inbound_message"

package/src/memory/conversation-bootstrap.ts

@@ -1,7 +1,7 @@
 import { createConversation } from "./conversation-crud.js";
 import {
-  GENERATING_TITLE,
-  queueGenerateConversationTitle,
+  AUTO_TITLE_DETERMINISTIC,
+  deriveDeterministicTitle,
   type TitleOrigin,
 } from "./conversation-title-service.js";
 
@@ -22,9 +22,23 @@ export interface BootstrapConversationOptions {
   forkParentConversationId?: string;
 }
 
+/**
+ * Create a system-initiated conversation with a deterministic title derived
+ * from `systemHint` — no LLM call. Background conversations (heartbeat runs,
+ * scheduled jobs, subagents, retrospectives) are created in bulk and rarely
+ * read by name, so an LLM-generated title is not worth the tokens. The title
+ * is persisted with `AUTO_TITLE_DETERMINISTIC`, which keeps it replaceable:
+ * if a user ever sends a message in the conversation, the title-generate
+ * hook upgrades it to an LLM title (see
+ * `plugins/defaults/title-generate/hooks/user-prompt-submit.ts`).
+ */
 export function bootstrapConversation(opts: BootstrapConversationOptions) {
-  const conversation = createConversation({
-    title: GENERATING_TITLE,
+  return createConversation({
+    title: deriveDeterministicTitle({
+      origin: opts.origin,
+      systemHint: opts.systemHint,
+    }),
+    isAutoTitle: AUTO_TITLE_DETERMINISTIC,
     ...(opts.conversationType && { conversationType: opts.conversationType }),
     ...(opts.source && { source: opts.source }),
     ...(opts.scheduleJobId && { scheduleJobId: opts.scheduleJobId }),
@@ -33,9 +47,4 @@ export function bootstrapConversation(opts: BootstrapConversationOptions) {
       forkParentConversationId: opts.forkParentConversationId,
     }),
   });
-  queueGenerateConversationTitle({
-    conversationId: conversation.id,
-    context: { origin: opts.origin, systemHint: opts.systemHint },
-  });
-  return conversation;
 }

package/src/memory/conversation-crud.ts

@@ -537,6 +537,13 @@ export function createConversation(
     | string
     | {
         title?: string;
+        /**
+         * Override the `is_auto_title` column (schema default 1). Pass
+         * `AUTO_TITLE_DETERMINISTIC` (2) when the title was derived
+         * deterministically at bootstrap so later generation passes know
+         * they may replace it.
+         */
+        isAutoTitle?: number;
         conversationType?: ConversationCreateType;
         source?: string;
         scheduleJobId?: string;
@@ -566,6 +573,9 @@ export function createConversation(
   const conversation = {
     id,
     title: opts.title ?? null,
+    ...(opts.isAutoTitle !== undefined
+      ? { isAutoTitle: opts.isAutoTitle }
+      : {}),
     createdAt: now,
     updatedAt: now,
     totalInputTokens: 0,
@@ -2039,8 +2049,8 @@ export interface OverrideProfileFields {
 /**
  * Resolve the per-turn inference-profile override from a conversation's
  * fields. Returns the `inferenceProfile` for interactive conversations,
- * `undefined` for automation threads (subagent fan-out, scheduled tasks,
- * update bulletins) so they run on the workspace defaults rather than
+ * `undefined` for automation threads (subagent fan-out, scheduled
+ * tasks) so they run on the workspace defaults rather than
  * inheriting an interactive override.
  */
 export function resolveOverrideProfile(

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

@@ -39,7 +39,6 @@ export type TitleOrigin =
   | "filing"
   | "local"
   | "task_submit"
-  | "updates_bulletin"
   | "memory_consolidation"
   | "memory_retrospective"
   | "misc";
@@ -63,6 +62,21 @@ export interface TitleContext {
 export const GENERATING_TITLE = "Generating title...";
 const UNTITLED_FALLBACK = "Untitled Conversation";
 
+// ── `conversations.isAutoTitle` values ───────────────────────────────
+//
+// Most readers treat the column as a boolean ("not user-set"); the two
+// distinct non-zero values let the title pipeline tell HOW a title was set.
+
+/** Title was generated by an LLM from conversation content. */
+export const AUTO_TITLE_LLM = 1;
+/**
+ * Title was derived deterministically from bootstrap context — no LLM call,
+ * no user input. Unlike LLM titles, these stay replaceable: the first
+ * genuine user message in the conversation upgrades them to an LLM title
+ * (see `canReplaceTitle`).
+ */
+export const AUTO_TITLE_DETERMINISTIC = 2;
+
 // ── Replaceability check ─────────────────────────────────────────────
 
 const REPLACEABLE_PATTERNS = [
@@ -83,6 +97,35 @@ export function isReplaceableTitle(title: string | null): boolean {
   return REPLACEABLE_PATTERNS.some((pattern) => pattern.test(title));
 }
 
+/**
+ * Whether auto-generation may overwrite the conversation's current title.
+ * True for placeholder/system titles and for deterministic bootstrap titles
+ * (`AUTO_TITLE_DETERMINISTIC`); false for user-set custom titles and titles
+ * already generated by an LLM.
+ */
+function canReplaceTitle(conversation: {
+  title: string | null;
+  isAutoTitle: number;
+}): boolean {
+  return (
+    isReplaceableTitle(conversation.title) ||
+    conversation.isAutoTitle === AUTO_TITLE_DETERMINISTIC
+  );
+}
+
+/**
+ * Derive a deterministic title from bootstrap context without an LLM call.
+ * Used for background/system conversations (heartbeat runs, scheduled jobs,
+ * subagents, retrospectives) where an LLM-generated title is not worth the
+ * tokens — the bootstrap `systemHint` already names the work. Persist it
+ * with `AUTO_TITLE_DETERMINISTIC` so a later genuine user message can still
+ * upgrade it to an LLM title.
+ */
+export function deriveDeterministicTitle(context: TitleContext): string {
+  const base = deriveFallbackTitle(context) ?? UNTITLED_FALLBACK;
+  return truncateTitle(base.replace(/\s+/g, " ").trim());
+}
+
 // ── Title generation ─────────────────────────────────────────────────
 
 export interface GenerateTitleParams {
@@ -111,16 +154,17 @@ export async function generateAndPersistConversationTitle(
 
   // Check current title is replaceable
   const conversation = getConversation(conversationId);
-  if (conversation && !isReplaceableTitle(conversation.title)) {
+  if (conversation && !canReplaceTitle(conversation)) {
     return { title: conversation.title!, updated: false };
   }
 
   const provider =
     params.provider ?? (await getConfiguredProvider("conversationTitle"));
   if (!provider) {
-    // No provider available — fall back to context-derived title or untitled
+    // No provider available — fall back to context-derived title or untitled.
+    // Deterministic, so keep it upgradeable by a later generation pass.
     const fallback = deriveFallbackTitle(context) ?? UNTITLED_FALLBACK;
-    updateConversationTitle(conversationId, fallback, 1);
+    updateConversationTitle(conversationId, fallback, AUTO_TITLE_DETERMINISTIC);
     publishConversationTitleChanged(conversationId, fallback);
     return { title: fallback, updated: true };
   }
@@ -139,11 +183,11 @@ export async function generateAndPersistConversationTitle(
   if (title) {
     // Re-check replaceability before persisting (race guard)
     const current = getConversation(conversationId);
-    if (current && !isReplaceableTitle(current.title)) {
+    if (current && !canReplaceTitle(current)) {
       return { title: current.title!, updated: false };
     }
 
-    updateConversationTitle(conversationId, title, 1);
+    updateConversationTitle(conversationId, title, AUTO_TITLE_LLM);
     publishConversationTitleChanged(conversationId, title);
     log.info({ conversationId, title }, "Auto-generated conversation title");
     return { title, updated: true };
@@ -155,12 +199,12 @@ export async function generateAndPersistConversationTitle(
   // while the LLM request was in-flight; writing unconditionally would
   // clobber the user's intent.
   const currentForFallback = getConversation(conversationId);
-  if (currentForFallback && !isReplaceableTitle(currentForFallback.title)) {
+  if (currentForFallback && !canReplaceTitle(currentForFallback)) {
     return { title: currentForFallback.title!, updated: false };
   }
 
   const fallback = deriveFallbackTitle(context) ?? UNTITLED_FALLBACK;
-  updateConversationTitle(conversationId, fallback, 1);
+  updateConversationTitle(conversationId, fallback, AUTO_TITLE_DETERMINISTIC);
   publishConversationTitleChanged(conversationId, fallback);
   return { title: fallback, updated: true };
 }
@@ -277,7 +321,7 @@ export async function regenerateConversationTitle(
       return { title: current?.title ?? UNTITLED_FALLBACK, updated: false };
     }
 
-    updateConversationTitle(conversationId, title, 1);
+    updateConversationTitle(conversationId, title, AUTO_TITLE_LLM);
     publishConversationTitleChanged(conversationId, title);
     log.info(
       { conversationId, title },