@vellumai/assistant 0.6.2 → 0.6.4

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

@@ -0,0 +1,127 @@
+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 { getLogger } from "../util/logger.js";
+import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
+import { getConversationType } from "./conversation-crud.js";
+import { upsertAutoAnalysisJob } from "./jobs-store.js";
+
+const log = getLogger("auto-analysis-enqueue");
+
+/**
+ * Trigger reason for an auto-analysis enqueue.
+ *   - `"batch"`: source conversation crossed the batch threshold — enqueue
+ *     immediately (`runAfter = now`) but still upsert so a pending job
+ *     coalesces rapid threshold crossings into one.
+ *   - `"idle"`: source conversation has been idle long enough to warrant a
+ *     debounced analysis pass.
+ *   - `"lifecycle"`: a conversation lifecycle transition (e.g. resume,
+ *     close) should trigger a debounced analysis pass.
+ *   - `"compaction"`: context was just compacted — some recent turns are
+ *     now hidden behind a summary, so crystallize anything worth
+ *     remembering before the window narrows further. Fires immediately
+ *     (`runAfter = now`) like `"batch"`.
+ */
+export type AutoAnalysisTrigger =
+  | "batch"
+  | "idle"
+  | "lifecycle"
+  | "compaction";
+
+/**
+ * Conditionally enqueue a `conversation_analyze` job for the given
+ * conversation. Skips silently when:
+ *   - the `auto-analyze` feature flag is disabled, OR
+ *   - the source conversation is itself an auto-analysis conversation
+ *     (recursion guard — we never analyze our own analysis output), OR
+ *   - the source conversation is private (`analyzeConversation` rejects
+ *     private conversations, so enqueueing would guarantee a failed job).
+ *
+ * Immediate triggers (`"batch"`, `"compaction"`) and debounced triggers
+ * (`"idle"`, `"lifecycle"`) are written to separate rows keyed by a
+ * `triggerGroup` discriminator. This prevents an idle enqueue from
+ * pushing an already-scheduled batch row's `runAfter` into the future
+ * (and vice versa). Within each group, rapid enqueues still coalesce to
+ * a single pending row via `upsertAutoAnalysisJob`.
+ */
+export function enqueueAutoAnalysisIfEnabled(args: {
+  conversationId: string;
+  trigger: AutoAnalysisTrigger;
+}): void {
+  const { conversationId, trigger } = args;
+
+  let config;
+  try {
+    config = getConfig();
+  } catch (err) {
+    log.warn(
+      { err, conversationId },
+      "Skipping auto-analysis enqueue: failed to load config",
+    );
+    return;
+  }
+
+  if (!isAssistantFeatureFlagEnabled("auto-analyze", config)) {
+    return;
+  }
+
+  if (isAutoAnalysisConversation(conversationId)) {
+    log.debug(
+      { conversationId, trigger },
+      "Skipping auto-analysis enqueue: source is an auto-analysis conversation",
+    );
+    return;
+  }
+
+  if (getConversationType(conversationId) === "private") {
+    log.debug(
+      { conversationId, trigger },
+      "Skipping auto-analysis enqueue: source is a private conversation",
+    );
+    return;
+  }
+
+  const idleTimeoutMs = config.analysis?.idleTimeoutMs ?? 600_000;
+  const runImmediately = trigger === "batch" || trigger === "compaction";
+  const triggerGroup: "immediate" | "debounced" = runImmediately
+    ? "immediate"
+    : "debounced";
+  const runAfter = runImmediately ? Date.now() : Date.now() + idleTimeoutMs;
+
+  try {
+    upsertAutoAnalysisJob({ conversationId, triggerGroup }, runAfter);
+  } catch (err) {
+    log.warn(
+      { err, conversationId, trigger },
+      "Failed to enqueue auto-analysis job",
+    );
+  }
+}
+
+/**
+ * Fire an auto-analysis enqueue from a compaction site. Wraps
+ * `enqueueAutoAnalysisIfEnabled` with the trust-class gate and
+ * best-effort error handling used at every compaction call site, so
+ * the six compaction paths (forceCompact, preflight, overflow reducer,
+ * mid-loop, and two emergency paths) stay in sync.
+ *
+ * Trust gate mirrors the memory-extraction trust boundary applied in
+ * `disposeConversation` — we don't trigger analysis (which runs with
+ * guardian trust + full tools) for conversations with an untrusted actor.
+ */
+export function enqueueAutoAnalysisOnCompaction(
+  conversationId: string,
+  trustClass: TrustClass | undefined,
+): void {
+  if (isUntrustedTrustClass(trustClass)) {
+    return;
+  }
+  try {
+    enqueueAutoAnalysisIfEnabled({ conversationId, trigger: "compaction" });
+  } catch {
+    // Best-effort — never block compaction on enqueue failures.
+  }
+}

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

@@ -0,0 +1,27 @@
+import { getConversationSource } from "./conversation-crud.js";
+
+/**
+ * The `source` value used for conversations created by the auto-analysis
+ * loop. Single source of truth — downstream code (enqueue helper,
+ * service auto-branch) imports this constant rather than hardcoding the
+ * string.
+ */
+export const AUTO_ANALYSIS_SOURCE = "auto-analysis";
+
+/**
+ * Dedicated `group_id` value for auto-analysis rolling conversations.
+ * Placed in the `system:background` group alongside heartbeat and filing
+ * conversations, rendered as a "Reflections" sub-group in the sidebar.
+ */
+export const AUTO_ANALYSIS_GROUP_ID = "system:background";
+
+/**
+ * Returns true if the conversation's `source` column is `"auto-analysis"`,
+ * meaning it was produced by the auto-analysis loop. Callers use this to
+ * skip both `graph_extract` and `conversation_analyze` enqueues so we
+ * never (a) analyze our own analysis output or (b) extract memory from
+ * reflective musings (the analysis agent writes memory directly via tools).
+ */
+export function isAutoAnalysisConversation(conversationId: string): boolean {
+  return getConversationSource(conversationId) === AUTO_ANALYSIS_SOURCE;
+}

package/src/memory/cleanup-schedule-state.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared state for the cleanup-scheduler throttle.
+ *
+ * `maybeEnqueueScheduledCleanupJobs` in jobs-worker.ts gates cleanup-job
+ * enqueueing behind a 6-hour window (configurable via
+ * memory.cleanup.enqueueIntervalMs). This module owns the "last enqueue"
+ * timestamp so that code paths outside jobs-worker — notably
+ * ConfigWatcher.refreshConfigFromSources — can reset the throttle without
+ * pulling in jobs-worker's large transitive import graph.
+ *
+ * The ConfigWatcher uses resetCleanupScheduleThrottle() to ensure that
+ * retention changes made via the UI (which flow through config.json →
+ * invalidateConfigCache → refreshConfigFromSources) take effect on the
+ * very next scheduler tick instead of waiting out the remaining window.
+ */
+
+let lastScheduledCleanupEnqueueMs = 0;
+
+/** Read the timestamp of the most recent enqueue (0 if never/reset). */
+export function getLastScheduledCleanupEnqueueMs(): number {
+  return lastScheduledCleanupEnqueueMs;
+}
+
+/** Record that an enqueue just happened at `nowMs`. */
+export function markScheduledCleanupEnqueued(nowMs: number): void {
+  lastScheduledCleanupEnqueueMs = nowMs;
+}
+
+/**
+ * Clear the throttle so the next `maybeEnqueueScheduledCleanupJobs` call
+ * bypasses the `enqueueIntervalMs` window. Used by ConfigWatcher when
+ * retention settings change, and by tests that need deterministic
+ * scheduling.
+ */
+export function resetCleanupScheduleThrottle(): void {
+  lastScheduledCleanupEnqueueMs = 0;
+}

package/src/memory/conversation-analyze-job.ts

@@ -0,0 +1,73 @@
+// ---------------------------------------------------------------------------
+// Auto-analyze — conversation_analyze job handler
+//
+// Bridges the jobs worker to the shared analyzeConversation() service. The
+// deps bundle is stashed on a module singleton during daemon startup; if it
+// isn't set yet we skip this iteration. The next batch / idle / lifecycle
+// trigger from `enqueueAutoAnalysisIfEnabled()` will produce a fresh job
+// once the daemon has fully started.
+//
+// The service itself distinguishes manual vs. auto triggers: this handler
+// always invokes with `trigger: "auto"`, so the rolling analysis conversation
+// logic and recursion guard apply.
+// ---------------------------------------------------------------------------
+
+import type { AssistantConfig } from "../config/types.js";
+import { analyzeConversation } from "../runtime/services/analyze-conversation.js";
+import { getAnalysisDeps } from "../runtime/services/analyze-deps-singleton.js";
+import { getLogger } from "../util/logger.js";
+import { enqueueAutoAnalysisIfEnabled } from "./auto-analysis-enqueue.js";
+import type { MemoryJob } from "./jobs-store.js";
+
+const log = getLogger("conversation-analyze-job");
+
+export async function conversationAnalyzeJob(
+  job: MemoryJob<{ conversationId?: string }>,
+  _config: AssistantConfig,
+): Promise<void> {
+  const { conversationId } = job.payload;
+  if (!conversationId) {
+    log.warn({ jobId: job.id }, "Skipping job: missing conversationId");
+    return;
+  }
+
+  const deps = getAnalysisDeps();
+  if (!deps) {
+    // Daemon hasn't finished startup. Return without throwing — a plain
+    // Error here would be classified as fatal by `classifyError()` and the
+    // worker would mark the job permanently failed. Throwing
+    // `BackendUnavailableError` would defer, but defer counters cap out and
+    // would still permanently fail in the worst case. Since
+    // `enqueueAutoAnalysisIfEnabled()` re-enqueues on the next batch / idle
+    // / lifecycle trigger, dropping this iteration is the safest choice and
+    // avoids retry storms during slow daemon startup.
+    log.warn(
+      { jobId: job.id, conversationId },
+      "Skipping job: analysis deps not yet initialized; will retrigger",
+    );
+    return;
+  }
+
+  const result = await analyzeConversation(conversationId, deps, {
+    trigger: "auto",
+  });
+  if ("error" in result) {
+    log.warn(
+      { jobId: job.id, conversationId, error: result.error },
+      "Auto-analysis service rejected source conversation",
+    );
+    return;
+  }
+  if (result.skipped) {
+    // The rolling analysis conversation was still processing a prior run, so
+    // this invocation was a no-op. Schedule a debounced follow-up ourselves
+    // — otherwise, if no later batch/idle/lifecycle trigger arrives (e.g.
+    // the conversation goes quiet after a long in-flight analysis), new
+    // source messages would stay un-analyzed indefinitely.
+    enqueueAutoAnalysisIfEnabled({ conversationId, trigger: "idle" });
+    log.debug(
+      { jobId: job.id, conversationId },
+      "Auto-analysis skipped (rolling conversation busy); requeued follow-up",
+    );
+  }
+}

package/src/memory/conversation-crud.ts

@@ -30,6 +30,7 @@ import {
   deleteOrphanAttachments,
   linkAttachmentToMessage,
 } from "./attachments-store.js";
+import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-guard.js";
 import {
   projectAssistantMessage,
   seedForkedConversationAttention,
@@ -170,9 +171,11 @@ export interface ConversationRow {
   originInterface: string | null;
   forkParentConversationId: string | null;
   forkParentMessageId: string | null;
+  hostAccess: number;
   isAutoTitle: number;
   scheduleJobId: string | null;
   lastMessageAt: number | null;
+  archivedAt: number | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -196,9 +199,11 @@ export const parseConversation = createRowMapper<
   originInterface: "originInterface",
   forkParentConversationId: "forkParentConversationId",
   forkParentMessageId: "forkParentMessageId",
+  hostAccess: "hostAccess",
   isAutoTitle: "isAutoTitle",
   scheduleJobId: "scheduleJobId",
   lastMessageAt: "lastMessageAt",
+  archivedAt: "archivedAt",
 });
 
 export interface MessageRow {
@@ -245,6 +250,8 @@ export function createConversation(
         source?: string;
         scheduleJobId?: string;
         groupId?: string;
+        hostAccess?: boolean;
+        forkParentConversationId?: string;
       },
 ) {
   const db = getDb();
@@ -276,10 +283,12 @@ export function createConversation(
     contextSummary: null as string | null,
     contextCompactedMessageCount: 0,
     contextCompactedAt: null as number | null,
+    hostAccess: opts.hostAccess ? 1 : 0,
     conversationType,
     source,
     memoryScopeId,
     scheduleJobId: opts.scheduleJobId ?? null,
+    forkParentConversationId: opts.forkParentConversationId ?? null,
   };
 
   // Retry on SQLITE_BUSY and SQLITE_IOERR — transient disk I/O errors or WAL
@@ -375,6 +384,54 @@ export function countConversationsByScheduleJobId(
   );
 }
 
+/**
+ * Find the rolling analysis conversation for a given source conversation,
+ * or null if none exists yet. Used by the auto-analyze loop to append
+ * to an existing analysis conversation rather than creating a new one
+ * each time the analyze job fires.
+ *
+ * Returns the most recently updated match if multiple exist (defensive —
+ * shouldn't happen in normal operation but the contract is well-defined).
+ *
+ * Hits `idx_conversations_fork_parent_conversation_id` for the
+ * `forkParentConversationId` lookup.
+ */
+export function findAnalysisConversationFor(
+  parentConversationId: string,
+): { id: string } | null {
+  const db = getDb();
+  const row = db
+    .select({ id: conversations.id })
+    .from(conversations)
+    .where(
+      and(
+        eq(conversations.source, AUTO_ANALYSIS_SOURCE),
+        eq(conversations.forkParentConversationId, parentConversationId),
+      ),
+    )
+    .orderBy(desc(conversations.updatedAt))
+    .limit(1)
+    .get();
+  return row ? { id: row.id } : null;
+}
+
+/**
+ * Returns the `source` column for the given conversation, or null if
+ * not found. Tiny convenience used by the recursion guard in the
+ * auto-analyze loop.
+ */
+export function getConversationSource(
+  conversationId: string,
+): string | null {
+  const db = getDb();
+  const row = db
+    .select({ source: conversations.source })
+    .from(conversations)
+    .where(eq(conversations.id, conversationId))
+    .get();
+  return row?.source ?? null;
+}
+
 export function getConversationType(
   conversationId: string,
 ): "standard" | "private" {
@@ -388,6 +445,11 @@ export function getConversationMemoryScopeId(conversationId: string): string {
   return conv?.memoryScopeId ?? "default";
 }
 
+export function getConversationHostAccess(conversationId: string): boolean {
+  const conv = getConversation(conversationId);
+  return conv?.hostAccess === 1;
+}
+
 /**
  * Fetch group_id for a conversation via raw SQL. group_id is NOT in the
  * Drizzle schema (raw-query-only pattern), so ConversationRow doesn't
@@ -1053,6 +1115,27 @@ export function getLastAssistantTimestampBefore(
   return row?.createdAt ?? 0;
 }
 
+export function getLastUserTimestampBefore(
+  conversationId: string,
+  beforeTimestamp: number,
+): number {
+  const db = getDb();
+  const row = db
+    .select({ createdAt: messages.createdAt })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        eq(messages.role, "user"),
+        lt(messages.createdAt, beforeTimestamp),
+      ),
+    )
+    .orderBy(desc(messages.createdAt))
+    .limit(1)
+    .get();
+  return row?.createdAt ?? 0;
+}
+
 /** Fetch a single message by ID, optionally scoped to a specific conversation. */
 export function getMessageById(
   messageId: string,
@@ -1123,6 +1206,45 @@ export function updateConversationContextWindow(
     .run();
 }
 
+export function updateConversationHostAccess(
+  id: string,
+  hostAccess: boolean,
+): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({
+      hostAccess: hostAccess ? 1 : 0,
+      updatedAt: Date.now(),
+    })
+    .where(eq(conversations.id, id))
+    .run();
+}
+
+export function archiveConversation(id: string): boolean {
+  const conv = getConversation(id);
+  if (!conv) return false;
+  const now = Date.now();
+  rawRun(
+    "UPDATE conversations SET archived_at = ?, updated_at = ? WHERE id = ?",
+    now,
+    now,
+    id,
+  );
+  return true;
+}
+
+export function unarchiveConversation(id: string): boolean {
+  const conv = getConversation(id);
+  if (!conv) return false;
+  const now = Date.now();
+  rawRun(
+    "UPDATE conversations SET archived_at = NULL, updated_at = ? WHERE id = ?",
+    now,
+    id,
+  );
+  return true;
+}
+
 /**
  * Delete all conversations, messages, and related data (tool invocations,
  * memory segments, etc.) from the daemon database.

package/src/memory/conversation-disk-view.ts

@@ -310,6 +310,13 @@ export function syncMessageToDisk(
     if (toolResults.length > 0) record.toolResults = toolResults;
     if (attachmentFilenames.length > 0)
       record.attachments = attachmentFilenames;
+    if (message.metadata) {
+      try {
+        record.metadata = JSON.parse(message.metadata);
+      } catch {
+        // Invalid JSON — omit metadata from disk record
+      }
+    }
 
     appendFileSync(
       join(dirPath, "messages.jsonl"),

package/src/memory/conversation-group-migration.ts

@@ -57,7 +57,11 @@ export function ensureGroupMigration(): void {
     }
   }
 
-  // 3. Seed system groups (four: pinned, scheduled, background, all)
+  // 3. Seed system groups.
+  //
+  // `system:reflections` is a legacy group kept for backward compatibility
+  // with existing installations. New auto-analysis conversations are assigned
+  // to `system:background`; the migration in step 6 moves existing ones.
   const now = Math.floor(Date.now() / 1000);
   rawExec(`
     INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group, created_at, updated_at)
@@ -65,7 +69,8 @@ export function ensureGroupMigration(): void {
       ('system:pinned', 'Pinned', 0, TRUE, ${now}, ${now}),
       ('system:scheduled', 'Scheduled', 1, TRUE, ${now}, ${now}),
       ('system:background', 'Background', 2, TRUE, ${now}, ${now}),
-      ('system:all', 'Recents', 3, TRUE, ${now}, ${now})
+      ('system:all', 'Recents', 3, TRUE, ${now}, ${now}),
+      ('system:reflections', 'Reflections', 100, TRUE, ${now}, ${now})
   `);
 
   // One-time migration: move system:all to sortPosition 3 (from 999999).
@@ -213,5 +218,32 @@ export function ensureGroupMigration(): void {
     }
   }
 
+  // 6. One-time migration: move auto-analysis conversations from system:reflections to system:background
+  const reflectionsMigrateDone = rawGet<{ id: string }>(
+    "SELECT id FROM conversation_groups WHERE id = '_reflections_to_background_complete'",
+  );
+
+  if (!reflectionsMigrateDone) {
+    try {
+      rawExec("BEGIN");
+
+      rawExec(`
+        UPDATE conversations SET group_id = 'system:background'
+        WHERE group_id = 'system:reflections'
+      `);
+
+      rawExec(`
+        INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group)
+        VALUES ('_reflections_to_background_complete', '_reflections_to_background_complete', -1, TRUE)
+      `);
+
+      rawExec("COMMIT");
+    } catch (err) {
+      rawExec("ROLLBACK");
+      log.error({ err }, "reflections-to-background migration failed, rolled back");
+      throw err;
+    }
+  }
+
   migrated = true;
 }

package/src/memory/conversation-queries.ts

@@ -218,7 +218,7 @@ export function searchConversations(
         FROM messages_fts f
         JOIN messages m ON m.id = f.message_id
         JOIN conversations c ON c.id = m.conversation_id
-        WHERE messages_fts MATCH ? AND c.conversation_type NOT IN ('background', 'private', 'scheduled')
+        WHERE messages_fts MATCH ? AND c.conversation_type NOT IN ('background', 'private', 'scheduled') AND c.archived_at IS NULL
         LIMIT 1000
       `,
         ftsMatch,
@@ -243,7 +243,7 @@ export function searchConversations(
       SELECT DISTINCT m.conversation_id
       FROM messages m
       JOIN conversations c ON c.id = m.conversation_id
-      WHERE m.content LIKE ? ESCAPE '\\' AND c.conversation_type NOT IN ('background', 'private', 'scheduled')
+      WHERE m.content LIKE ? ESCAPE '\\' AND c.conversation_type NOT IN ('background', 'private', 'scheduled') AND c.archived_at IS NULL
       LIMIT 1000
     `,
       likePattern,
@@ -257,9 +257,10 @@ export function searchConversations(
     .from(conversations)
     .where(
       and(
-        sql`${conversations.conversationType} NOT IN ('background', 'private', 'scheduled')`,
-        sql`${conversations.title} LIKE ${titlePattern} ESCAPE '\\'`,
-      ),
+          sql`${conversations.conversationType} NOT IN ('background', 'private', 'scheduled')`,
+          sql`${conversations.title} LIKE ${titlePattern} ESCAPE '\\'`,
+          sql`${conversations.archivedAt} IS NULL`,
+        ),
     )
     .all();
   for (const row of titleMatchConvs) ftsConvIds.add(row.id);

package/src/memory/conversation-starters-cadence.ts

@@ -0,0 +1,76 @@
+/**
+ * Cadence logic for conversation starters generation.
+ *
+ * Decides whether a new generation job should be enqueued based on how many
+ * active memory items have accumulated since the last generation.
+ */
+
+import { and, eq, inArray, sql } from "drizzle-orm";
+
+import { getLogger } from "../util/logger.js";
+import { getDb } from "./db.js";
+import { enqueueMemoryJob } from "./jobs-store.js";
+import { rawGet } from "./raw-query.js";
+import { memoryCheckpoints, memoryJobs } from "./schema.js";
+
+const log = getLogger("conversation-starters-cadence");
+
+/**
+ * Check whether enough new memory items have accumulated to justify
+ * generating a fresh batch of conversation starters.
+ */
+export function maybeEnqueueConversationStartersJob(scopeId: string): void {
+  const db = getDb();
+
+  // Count total active memory items
+  const countRow = rawGet<{ c: number }>(
+    `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
+    scopeId,
+  );
+  const totalActive = countRow?.c ?? 0;
+  if (totalActive === 0) return;
+
+  // Read checkpoint: item count at last generation (scoped so each scope tracks independently)
+  const checkpointKey = `conversation_starters:item_count_at_last_gen:${scopeId}`;
+  const checkpoint = db
+    .select({ value: memoryCheckpoints.value })
+    .from(memoryCheckpoints)
+    .where(eq(memoryCheckpoints.key, checkpointKey))
+    .get();
+  const parsedLastCount = checkpoint ? parseInt(checkpoint.value, 10) : 0;
+  const lastCount = Number.isFinite(parsedLastCount) ? parsedLastCount : 0;
+
+  // Cadence formula
+  let threshold: number;
+  if (totalActive <= 10) {
+    threshold = 1;
+  } else if (totalActive <= 50) {
+    threshold = 5;
+  } else {
+    threshold = 10;
+  }
+
+  const checkpointAhead = totalActive < lastCount;
+  const delta = Math.max(0, totalActive - lastCount);
+  if (!checkpointAhead && delta < threshold) return;
+
+  // Dedup: don't enqueue if a pending/running job for this scope already exists
+  const existing = db
+    .select({ id: memoryJobs.id })
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "generate_conversation_starters"),
+        inArray(memoryJobs.status, ["pending", "running"]),
+        sql`json_extract(${memoryJobs.payload}, '$.scopeId') = ${scopeId}`,
+      ),
+    )
+    .get();
+  if (existing) return;
+
+  enqueueMemoryJob("generate_conversation_starters", { scopeId });
+  log.info(
+    { totalActive, lastCount, delta, threshold, scopeId, checkpointAhead },
+    "Enqueued conversation starters generation job",
+  );
+}

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

@@ -284,10 +284,13 @@ export function queueRegenerateConversationTitle(
  */
 function buildTitleSystemPrompt(): string {
   return [
-    "You generate short conversation titles. Output ONLY the title text — no explanation, no quotes, no markdown, no preamble.",
+    "You generate ultra-concise conversation titles. Output ONLY the title text — no explanation, no quotes, no markdown, no preamble.",
     "",
     "Rules:",
-    "- Summarize the TOPIC the user is asking about",
+    "- 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')",
+    "- 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",
   ].join("\n");