@openchambery/web 1.18.4-beta.9 → 1.18.5

package/server/lib/session-assist/runtime.js

@@ -33,6 +33,8 @@ const isSessionRecapEnabled = () => {
 
 const IDLE_QUIET_MS = 60_000;
 const TRANSCRIPT_MESSAGE_LIMIT = 12;
+/** Latest real user messages fed to the recap prompt. */
+const TRANSCRIPT_USER_MESSAGE_LIMIT = 3;
 const TRANSCRIPT_PART_CHAR_LIMIT = 6_000;
 const RECAP_CHAR_LIMIT = 320;
 const FETCH_TIMEOUT_MS = 5_000;
@@ -92,13 +94,63 @@ const extractUserMessage = (payload) => {
   };
 };
 
-const messagePartsToText = (message) => {
+/** Real (non-synthetic) text parts of a message — hidden instructions excluded. */
+const realTextParts = (message) => {
   const parts = Array.isArray(message?.parts) ? message.parts : [];
   return parts
-    .map((part) => (part?.type === 'text' && typeof part.text === 'string' ? part.text : ''))
-    .filter(Boolean)
-    .join('\n')
-    .slice(0, TRANSCRIPT_PART_CHAR_LIMIT);
+    .filter((part) => part?.type === 'text'
+      && typeof part.text === 'string'
+      && part.text.trim().length > 0
+      && part.synthetic !== true)
+    .map((part) => part.text);
+};
+
+/** Body text of a message: only its LAST text block, char-clamped. */
+const lastMessageText = (message) => {
+  const texts = realTextParts(message);
+  return texts.length > 0 ? texts[texts.length - 1].slice(0, TRANSCRIPT_PART_CHAR_LIMIT) : '';
+};
+
+/**
+ * Build the recap transcript from a bounded recent-message window.
+ * - Assistant: only the LAST text block of the last assistant message —
+ *   earlier blocks, reasoning, and tool output are token waste for a
+ *   one-line recap.
+ * - User: the latest real user messages (default 3), chronological.
+ */
+export const buildAssistTranscript = (
+  messages,
+  { userLimit = TRANSCRIPT_USER_MESSAGE_LIMIT } = {},
+) => {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { transcript: '', assistantInfo: null, userTexts: [], assistantText: '' };
+  }
+  let lastAssistant = null;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i]?.info?.role === 'assistant') {
+      lastAssistant = messages[i];
+      break;
+    }
+  }
+  const lastAssistantInfo = lastAssistant?.info ?? null;
+  if (!lastAssistantInfo?.id) {
+    return { transcript: '', assistantInfo: null, userTexts: [], assistantText: '' };
+  }
+
+  const userTexts = [];
+  for (let i = messages.length - 1; i >= 0 && userTexts.length < userLimit; i -= 1) {
+    const message = messages[i];
+    if (message?.info?.role !== 'user') continue;
+    const text = lastMessageText(message);
+    if (!text) continue;
+    userTexts.unshift(text);
+  }
+  const assistantText = lastMessageText(lastAssistant);
+  const transcript = [
+    ...userTexts.map((text) => `User:\n${text}`),
+    assistantText ? `Assistant:\n${assistantText}` : '',
+  ].filter(Boolean).join('\n\n');
+  return { transcript, assistantInfo: lastAssistantInfo, userTexts, assistantText };
 };
 
 export const createSessionAssistRuntime = ({
@@ -169,36 +221,21 @@ export const createSessionAssistRuntime = ({
       return;
     }
 
-    let lastAssistant = null;
-    for (let i = messages.length - 1; i >= 0; i -= 1) {
-      const info = messages[i]?.info;
-      if (info?.role === 'assistant') {
-        lastAssistant = messages[i];
-        break;
-      }
-    }
-    const lastAssistantInfo = lastAssistant?.info;
+    // Trimmed extraction for a one-line recap: the last assistant text block
+    // plus the latest real user messages. Everything else (earlier blocks,
+    // reasoning, tool output, older turns) is token waste.
+    const { transcript, assistantInfo: lastAssistantInfo, userTexts, assistantText } = buildAssistTranscript(messages);
     if (!lastAssistantInfo?.id) return;
-
-    // Only the last exchange: the assistant reply plus the user message it
-    // answered (assistant info.parentID → user info.id). Everything else is
-    // token waste for a one-line recap.
-    const parentUserMessage = typeof lastAssistantInfo.parentID === 'string' && lastAssistantInfo.parentID
-      ? messages.find((message) => message?.info?.id === lastAssistantInfo.parentID && message?.info?.role === 'user')
-      : null;
-    const userText = parentUserMessage ? messagePartsToText(parentUserMessage) : '';
-    const assistantText = messagePartsToText(lastAssistant);
-    const transcript = [
-      userText ? `User:\n${userText}` : '',
-      assistantText ? `Assistant:\n${assistantText}` : '',
-    ].filter(Boolean).join('\n\n');
     if (!transcript) return;
 
     const { generateSmallModelText } = await getSmallModelService();
     // Instruct the language by example, not by description — account-side
     // personalization (e.g. the ChatGPT backend knowing the user's locale)
     // otherwise leaks a different language into the output.
-    const languageSample = (userText || assistantText).slice(0, 200).replace(/\s+/g, ' ').trim();
+    const languageSample = (userTexts[userTexts.length - 1] || assistantText)
+      .slice(0, 200)
+      .replace(/\s+/g, ' ')
+      .trim();
     let generated;
     try {
       generated = await generateSmallModelText({
@@ -206,7 +243,7 @@ export const createSessionAssistRuntime = ({
         // session's own provider unless the user explicitly picked a small
         // model (settings override / opencode config).
         restrictToPreferredProvider: true,
-        prompt: `The latest exchange in the conversation:\n\n${transcript}\n\nWrite recap in the SAME language as this sample from the conversation: "${languageSample}"`,
+        prompt: `The latest conversation excerpt:\n\n${transcript}\n\nWrite recap in the SAME language as this sample from the conversation: "${languageSample}"`,
         system: ASSIST_SYSTEM_PROMPT,
         directory,
         preferredProviderID: typeof lastAssistantInfo.providerID === 'string' ? lastAssistantInfo.providerID : undefined,
@@ -228,7 +265,7 @@ export const createSessionAssistRuntime = ({
     // no Cyrillic/CJK at all, the output must not either.
     const hasCyrillic = (text) => /[\u0400-\u04FF]/.test(text);
     const hasCjk = (text) => /[\u3040-\u30FF\u4E00-\u9FFF\uAC00-\uD7AF]/.test(text);
-    const inputText = `${userText}\n${assistantText}`;
+    const inputText = `${userTexts.join('\n')}\n${assistantText}`;
     const scriptMismatch = (text) => (hasCyrillic(text) && !hasCyrillic(inputText))
       || (hasCjk(text) && !hasCjk(inputText));
     if (recap && scriptMismatch(recap)) {

package/server/lib/session-assist/runtime.test.js

@@ -0,0 +1,114 @@
+import { describe, expect, test } from 'vitest';
+import { buildAssistTranscript } from './runtime.js';
+
+const textPart = (text, { synthetic = false } = {}) => ({
+  type: 'text',
+  text,
+  ...(synthetic ? { synthetic: true } : {}),
+});
+
+const userMessage = (id, parts) => ({ info: { id, role: 'user' }, parts });
+const assistantMessage = (id, parts) => ({ info: { id, role: 'assistant' }, parts });
+
+describe('buildAssistTranscript', () => {
+  test('assistant keeps only the LAST text block of the last assistant message', () => {
+    const result = buildAssistTranscript([
+      userMessage('u1', [textPart('first user message')]),
+      assistantMessage('a1', [textPart('old assistant reply')]),
+      userMessage('u2', [textPart('second user message')]),
+      assistantMessage('a2', [
+        textPart('intro before tools'),
+        { type: 'tool', tool: 'bash' },
+        textPart('final body text'),
+      ]),
+    ]);
+    expect(result.assistantInfo.id).toBe('a2');
+    expect(result.assistantText).toBe('final body text');
+    expect(result.transcript).toBe(
+      'User:\nfirst user message\n\nUser:\nsecond user message\n\nAssistant:\nfinal body text',
+    );
+  });
+
+  test('reasoning parts never enter the transcript', () => {
+    const result = buildAssistTranscript([
+      userMessage('u1', [textPart('请帮我看看')]),
+      assistantMessage('a1', [
+        { type: 'reasoning', text: 'thinking about the problem' },
+        textPart('最终答复'),
+      ]),
+    ]);
+    expect(result.transcript).toBe('User:\n请帮我看看\n\nAssistant:\n最终答复');
+    expect(result.transcript).not.toContain('thinking');
+  });
+
+  test('user side keeps only the latest 3 real user messages, chronologically', () => {
+    const result = buildAssistTranscript([
+      userMessage('u1', [textPart('question 1')]),
+      assistantMessage('a1', [textPart('answer 1')]),
+      userMessage('u2', [textPart('question 2')]),
+      assistantMessage('a2', [textPart('answer 2')]),
+      userMessage('u3', [textPart('question 3')]),
+      userMessage('u4', [textPart('question 4')]),
+      assistantMessage('a3', [textPart('answer 3')]),
+    ]);
+    expect(result.userTexts).toEqual(['question 2', 'question 3', 'question 4']);
+    expect(result.transcript).toBe(
+      'User:\nquestion 2\n\nUser:\nquestion 3\n\nUser:\nquestion 4\n\nAssistant:\nanswer 3',
+    );
+  });
+
+  test('synthetic-only user messages do not count toward the user window', () => {
+    const result = buildAssistTranscript([
+      userMessage('u1', [textPart('visible request')]),
+      userMessage('u2', [textPart('hidden instruction', { synthetic: true })]),
+      userMessage('u3', [textPart('real follow-up')]),
+      assistantMessage('a1', [textPart('reply body')]),
+    ]);
+    expect(result.userTexts).toEqual(['visible request', 'real follow-up']);
+    expect(result.transcript).not.toContain('hidden instruction');
+  });
+
+  test('synthetic instruction part on a real user message is dropped', () => {
+    const result = buildAssistTranscript([
+      userMessage('u1', [
+        textPart('visible request'),
+        textPart('/summary hidden instructions', { synthetic: true }),
+      ]),
+      assistantMessage('a1', [textPart('reply body')]),
+    ]);
+    expect(result.userTexts).toEqual(['visible request']);
+    expect(result.transcript).not.toContain('/summary hidden instructions');
+  });
+
+  test('fewer than 3 user messages keeps all of them', () => {
+    const result = buildAssistTranscript([
+      userMessage('u1', [textPart('only question')]),
+      assistantMessage('a1', [textPart('only answer')]),
+    ]);
+    expect(result.userTexts).toEqual(['only question']);
+    expect(result.transcript).toBe('User:\nonly question\n\nAssistant:\nonly answer');
+  });
+
+  test('no assistant message yields an empty transcript', () => {
+    const result = buildAssistTranscript([
+      userMessage('u1', [textPart('unanswered question')]),
+    ]);
+    expect(result.transcript).toBe('');
+    expect(result.assistantInfo).toBeNull();
+    expect(result.userTexts).toEqual([]);
+  });
+
+  test('assistant with no text parts still summarizes the user side', () => {
+    const result = buildAssistTranscript([
+      userMessage('u1', [textPart('question')]),
+      assistantMessage('a1', [{ type: 'tool', tool: 'bash' }]),
+    ]);
+    expect(result.assistantInfo.id).toBe('a1');
+    expect(result.transcript).toBe('User:\nquestion');
+  });
+
+  test('empty input yields an empty transcript', () => {
+    expect(buildAssistTranscript([]).transcript).toBe('');
+    expect(buildAssistTranscript(null).transcript).toBe('');
+  });
+});

package/server/lib/session-index/DOCUMENTATION.md

@@ -20,13 +20,19 @@ the index excludes them from every snapshot and clears prior summaries when a
   `metadata.openchamber.smallModel.purpose`. Title prefixes are human labels and
   never participate in this filter. Metadata is the ownership/isolation signal;
 `time.archived` is archive state; `time.pinned` is OpenChamber-owned pin state
-(persisted as `pinned_at`, rescued across directory rebuilds, never overwritten
-by live OpenCode upserts); titles are for recognition. The index does
+overlaid from the independent `session_pin` table (also mirrored onto in-window
+`session_summary.pinned_at` for older readers). Pins are not subject to the
+newest-20 summary bound: evicting or rebuilding a directory keeps pin
+membership, and `setPinned` can target a session that is not currently in the
+index. Archive or `remove` still clears the pin. Live OpenCode upserts never
+overwrite pin membership. Titles are for recognition. The index does
 not cache system sessions, so cold-start and live upserts stay aligned with
 ordinary sidebar lists.
 Pin and unpin use `POST` / `DELETE`
-`/api/openchamber/session-index/session/:id/pin`, update `pinned_at`, then
+`/api/openchamber/session-index/session/:id/pin`, write `session_pin`, then
 `publishChange()` so revision tips broadcast `openchamber:session-index-changed`.
+Snapshots include `pinnedSessionIds` plus `time.pinned` on any matching
+summary row.
 
 The server-side global OpenCode event subscriber writes session summary events
 directly into this index. User `message.updated` events and `session.idle`

package/server/lib/session-index/service.js

@@ -140,6 +140,12 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
       ON session_summary(runtime_key, directory, activity_updated_at DESC, session_id DESC);
     CREATE INDEX IF NOT EXISTS session_child_parent
       ON session_child(runtime_key, directory, parent_id);
+    CREATE TABLE IF NOT EXISTS session_pin (
+      runtime_key TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      pinned_at INTEGER NOT NULL,
+      PRIMARY KEY (runtime_key, session_id)
+    );
   `);
   const sessionSummaryColumns = new Set(
     db.prepare("SELECT name FROM pragma_table_info('session_summary')").all().map((column) => column.name),
@@ -147,6 +153,12 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
   if (!sessionSummaryColumns.has('pinned_at')) {
     db.exec('ALTER TABLE session_summary ADD COLUMN pinned_at INTEGER');
   }
+  db.prepare(`
+    INSERT OR IGNORE INTO session_pin(runtime_key, session_id, pinned_at)
+    SELECT runtime_key, session_id, pinned_at
+    FROM session_summary
+    WHERE pinned_at IS NOT NULL
+  `).run();
   db.prepare('INSERT OR REPLACE INTO session_index_meta(key, value) VALUES (?, ?)')
     .run('schema_version', String(SCHEMA_VERSION));
 
@@ -240,6 +252,23 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     SELECT COUNT(*) AS count FROM session_child
     WHERE runtime_key = ? AND directory = ? AND parent_id = ?
   `);
+  const readPins = db.prepare(`
+    SELECT session_id AS id, pinned_at AS pinnedAt
+    FROM session_pin
+    WHERE runtime_key = ?
+    ORDER BY pinned_at DESC, session_id DESC
+  `);
+  const upsertPin = db.prepare(`
+    INSERT INTO session_pin(runtime_key, session_id, pinned_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(runtime_key, session_id) DO UPDATE SET pinned_at = excluded.pinned_at
+  `);
+  const deletePin = db.prepare('DELETE FROM session_pin WHERE runtime_key = ? AND session_id = ?');
+  const writeSummaryPinnedAt = db.prepare(`
+    UPDATE session_summary
+    SET pinned_at = ?
+    WHERE runtime_key = ? AND session_id = ?
+  `);
 
   const replaceDirectoryRows = ({ directory, sessions, cursor, hasMore, fullSync = true, now = Date.now() }) => {
     const normalizedDirectory = normalizeDirectory(directory);
@@ -363,6 +392,8 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
 
   const snapshot = () => {
     const key = runtimeKey();
+    const pinRows = readPins.all(key);
+    const pinById = new Map(pinRows.map((row) => [row.id, row.pinnedAt]));
     const directories = db.prepare(`
       SELECT directory, cursor, has_more AS hasMore, last_synced_at AS lastSyncedAt,
         last_full_synced_at AS lastFullSyncedAt, last_accessed_at AS lastAccessedAt
@@ -387,7 +418,9 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
             created: session.createdAt,
             updated: session.updatedAt,
             ...(session.archivedAt ? { archived: session.archivedAt } : {}),
-            ...(session.pinnedAt ? { pinned: session.pinnedAt } : {}),
+            ...((pinById.get(session.id) ?? session.pinnedAt)
+              ? { pinned: pinById.get(session.id) ?? session.pinnedAt }
+              : {}),
           },
           metadata: {
             openchamber: {
@@ -401,13 +434,17 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
         }))
         .filter(isVisibleSession),
     }));
-    return { directories };
+    return {
+      directories,
+      pinnedSessionIds: pinRows.map((row) => row.id),
+    };
   };
 
   function remove(sessionID) {
     if (typeof sessionID !== 'string' || !sessionID) return false;
     const key = runtimeKey();
     const parent = parentForChild.get(key, sessionID);
+    const pinResult = deletePin.run(key, sessionID);
     const result = db.prepare('DELETE FROM session_summary WHERE runtime_key = ? AND session_id = ?').run(key, sessionID);
     deleteChildrenWithParent.run(key, sessionID);
     deleteChild.run(key, sessionID);
@@ -419,7 +456,7 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
         parent.parentID,
       );
     }
-    return result.changes > 0;
+    return result.changes > 0 || pinResult.changes > 0;
   }
 
   /**
@@ -480,36 +517,22 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     return result.changes > 0;
   };
 
-  const summaryExists = db.prepare(`
-    SELECT 1 AS present FROM session_summary
-    WHERE runtime_key = ? AND session_id = ?
-    LIMIT 1
-  `);
-
   const setPinned = (sessionID, pinnedAt = Date.now()) => {
     if (typeof sessionID !== 'string' || !sessionID) return false;
     const timestamp = toTimestamp(pinnedAt);
     if (!timestamp) return false;
     const key = runtimeKey();
-    if (!summaryExists.get(key, sessionID)) return false;
-    db.prepare(`
-      UPDATE session_summary
-      SET pinned_at = ?
-      WHERE runtime_key = ? AND session_id = ?
-    `).run(timestamp, key, sessionID);
+    upsertPin.run(key, sessionID, timestamp);
+    writeSummaryPinnedAt.run(timestamp, key, sessionID);
     return true;
   };
 
   const clearPinned = (sessionID) => {
     if (typeof sessionID !== 'string' || !sessionID) return false;
     const key = runtimeKey();
-    if (!summaryExists.get(key, sessionID)) return false;
-    db.prepare(`
-      UPDATE session_summary
-      SET pinned_at = NULL
-      WHERE runtime_key = ? AND session_id = ?
-    `).run(key, sessionID);
-    return true;
+    const pinResult = deletePin.run(key, sessionID);
+    const summaryResult = writeSummaryPinnedAt.run(null, key, sessionID);
+    return pinResult.changes > 0 || summaryResult.changes > 0;
   };
 
   const replaceChildSessions = db.transaction((directory, parentSessionID, children) => {

package/server/lib/session-index/service.test.js

@@ -385,7 +385,88 @@ describe('Electron session index', () => {
 
     expect(service.upsert({ ...session('ses_a', 11), time: { created: 9, updated: 11, archived: 12 } })).toBe(true);
     expect(service.snapshot().directories[0].sessions).toEqual([]);
+    expect(service.snapshot().pinnedSessionIds ?? []).not.toContain('ses_a');
     expect(service.clearPinned('ses_a')).toBe(false);
     service.close();
   });
+
+  it('keeps a pin after the session falls outside the newest-20 rebuild window', () => {
+    const runtimeRef = { value: 'http://runtime-a.test' };
+    const service = createService(runtimeRef);
+    service.replaceDirectory({
+      directory: '/repo',
+      sessions: [session('ses_pinned', 10)],
+      cursor: null,
+      hasMore: false,
+    });
+    expect(service.setPinned('ses_pinned', 42)).toBe(true);
+
+    const newer = Array.from({ length: 20 }, (_, index) => session(`ses_new_${index}`, 200 - index));
+    service.replaceDirectory({ directory: '/repo', sessions: newer, cursor: null, hasMore: true, now: 3000 });
+
+    const snapshot = service.snapshot();
+    expect(snapshot.directories[0].sessions).toHaveLength(20);
+    expect(snapshot.directories[0].sessions.some((item) => item.id === 'ses_pinned')).toBe(false);
+    expect(snapshot.pinnedSessionIds).toEqual(['ses_pinned']);
+    service.close();
+  });
+
+  it('keeps a pin after live upserts evict the pinned summary row', () => {
+    const runtimeRef = { value: 'http://runtime-a.test' };
+    const service = createService(runtimeRef);
+    service.replaceDirectory({
+      directory: '/repo',
+      sessions: [session('ses_pinned', 10)],
+      cursor: null,
+      hasMore: false,
+    });
+    expect(service.setPinned('ses_pinned', 43)).toBe(true);
+
+    for (let index = 0; index < 20; index += 1) {
+      service.upsert(session(`ses_new_${index}`, 200 - index));
+    }
+
+    const snapshot = service.snapshot();
+    expect(snapshot.directories[0].sessions).toHaveLength(20);
+    expect(snapshot.directories[0].sessions.some((item) => item.id === 'ses_pinned')).toBe(false);
+    expect(snapshot.pinnedSessionIds).toEqual(['ses_pinned']);
+    service.close();
+  });
+
+  it('backfills session_pin from existing summary pinned_at on open', () => {
+    const runtimeRef = { value: 'http://runtime-a.test' };
+    const service = createService(runtimeRef);
+    service.replaceDirectory({ directory: '/repo', sessions: [session('ses_a', 10)], cursor: null, hasMore: false });
+    expect(service.setPinned('ses_a', 66)).toBe(true);
+    service.close();
+
+    const dbPath = path.join(tempDirectories[tempDirectories.length - 1], 'session-index.sqlite');
+    const Database = createRequire(import.meta.url)('better-sqlite3');
+    const db = new Database(dbPath);
+    db.exec('DELETE FROM session_pin');
+    db.close();
+
+    const reopened = createSessionIndexService({
+      dbPath,
+      getRuntimeConfig: () => ({ apiBaseUrl: runtimeRef.value }),
+    });
+    expect(reopened.snapshot().pinnedSessionIds).toEqual(['ses_a']);
+    expect(reopened.snapshot().directories[0].sessions[0].time.pinned).toBe(66);
+    reopened.close();
+  });
+
+  it('pins a session that is not in the newest-20 index', () => {
+    const runtimeRef = { value: 'http://runtime-a.test' };
+    const service = createService(runtimeRef);
+    const newest = Array.from({ length: 20 }, (_, index) => session(`ses_${index}`, 100 - index));
+    service.replaceDirectory({ directory: '/repo', sessions: newest, cursor: 80, hasMore: true, now: 1000 });
+
+    expect(service.setPinned('ses_old', 55)).toBe(true);
+    expect(service.snapshot().pinnedSessionIds).toEqual(['ses_old']);
+    expect(service.snapshot().directories[0].sessions.some((item) => item.id === 'ses_old')).toBe(false);
+
+    expect(service.clearPinned('ses_old')).toBe(true);
+    expect(service.snapshot().pinnedSessionIds ?? []).toEqual([]);
+    service.close();
+  });
 });

package/server/lib/session-title/DOCUMENTATION.md

@@ -18,16 +18,21 @@ throttle (`TITLE_THROTTLE_MS`) when a refresh is armed.
    pattern as session-assist. Purely event-driven — dormant sessions never
    generate anything.
   2. Auto title refresh is intentionally sparse (title stability first). A newly
-    observed root `session.created` generates its first title immediately on the
-    first `session.status: idle`. A fork title (`(fork #n)`) waits for its first
-    newly-created user message; the matching assistant completion triggers an
-    immediate title refresh that bypasses inherited title metadata and throttle.
-    Ordinary later idle transitions do **not** arm another refresh. Any
-    `busy`/`retry` status or a fresh user `message.updated` still clears an
-    already-armed timer (so initial/fork timers cancel if the user keeps going).
-    A sidebar smart-title request sets `titleRefresh.requestedAt`; its
-    `session.updated` event arms the same flow immediately (forced / manual
-    refresh is unaffected by the background gate).
+     observed root `session.created` generates its first title immediately on the
+     first `session.status: idle`. A fork title (`(fork #n)`) waits for its first
+     newly-created user message; the matching assistant completion triggers an
+     immediate title refresh that bypasses inherited title metadata and throttle.
+     If the fork's `session.created` was lost (SSE reconnect gap, server or
+     OpenCode restart), the first newly-created user message lazily re-registers
+     the pending fork from the session read inside `recordUserActivity` (fork
+     title + message created after the fork + activity timestamp not yet past
+     the fork time), so the first-reply refresh still fires.
+     Ordinary later idle transitions do **not** arm another refresh. Any
+     `busy`/`retry` status or a fresh user `message.updated` still clears an
+     already-armed timer (so initial/fork timers cancel if the user keeps going).
+     A sidebar smart-title request sets `titleRefresh.requestedAt`; its
+     `session.updated` event arms the same flow immediately (forced / manual
+     refresh is unaffected by the background gate).
   3. On fire:
     - Skip when Settings → Chat → session title refresh is off.
     - Skip system-owned sessions whose metadata carries a non-empty

package/server/lib/session-title/runtime.js

@@ -484,6 +484,30 @@ export const createSessionTitleRuntime = ({
     if (!session || typeof session !== 'object') return;
 
     const meta = readTitleRefreshMeta(session);
+
+    // Lazy fork registration: when the fork's `session.created` event was lost
+    // (SSE reconnect gap, server/OpenCode restart), the in-memory pending map
+    // never learned about the fork. The first newly-created user message on a
+    // fork-titled session (message created after the fork, before any activity
+    // timestamp advanced past the fork) rebuilds that pending entry so the
+    // matching idle still triggers the first-refresh. Idempotent: the normal
+    // session.created path already holds a pending entry, and once activity
+    // advances past the fork time later messages never re-register.
+    const forkCreated = Number(session?.time?.created);
+    if (
+      !forkFirstSendPending.has(sessionId)
+      && isForkedSessionTitle(typeof session.title === 'string' ? session.title : '')
+      && Number.isFinite(forkCreated)
+      && createdAt > forkCreated
+      && !(Number(meta.titleRefresh.activityUpdatedAt) > forkCreated)
+    ) {
+      forkFirstSendPending.set(sessionId, {
+        createdAt: forkCreated,
+        directory: directory || '',
+        hasNewUserMessage: true,
+      });
+    }
+
     const previous = Number(meta.titleRefresh.activityUpdatedAt);
     const activityUpdatedAt = Number.isFinite(previous) ? Math.max(previous, createdAt) : createdAt;
     if (activityUpdatedAt === previous) return;