@openchambery/web 2.0.0-beta.22 → 2.0.0-beta.24

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

@@ -722,20 +722,20 @@ export const createSessionGoalRuntime = ({
       const client = openCodeClient();
       if (typeof client?.message?.list === 'function') {
         const listed = await client.message.list(
-          { sessionID: sessionId, limit: MESSAGE_FETCH_LIMIT, order: 'asc' },
+          { sessionID: sessionId, limit: MESSAGE_FETCH_LIMIT, order: 'desc' },
           directoryRequestOptions(directory),
         );
         const projected = projectGoalMessages(listed, sessionId);
-        if (projected) return projected;
+        if (projected) return projected.reverse();
       }
     } catch {
       // Fall through to controlled HTTP seam for tests / older fixtures.
     }
     const raw = await openCodeFetch(`/session/${encodeURIComponent(sessionId)}/message`, {
       directory,
-      query: { limit: String(MESSAGE_FETCH_LIMIT) },
+      query: { limit: String(MESSAGE_FETCH_LIMIT), order: 'desc' },
     }).catch(() => null);
-    return projectGoalMessages(raw, sessionId);
+    return projectGoalMessages(raw, sessionId)?.reverse() ?? null;
   };
 
   /**

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

@@ -136,7 +136,7 @@ const makeFetch = ({ messages, liveStatus }) => {
       }
       if (pathEndsWith(reqPath, '/session/ses-goal/message')) {
         // Official v2 SessionMessagesResponse shape.
-        return jsonResponse({ data: messages, cursor: {} });
+        return jsonResponse({ data: new URL(url).searchParams.get('order') === 'desc' ? [...messages].reverse() : messages, cursor: {} });
       }
       if (pathEndsWith(reqPath, '/session/ses-goal') && !reqPath.includes('/message')) {
         if (init.method === 'PATCH') {
@@ -263,6 +263,33 @@ describe('session-goal v2 message projection helpers', () => {
 });
 
 describe('session-goal continuation delivery', () => {
+  it.each([false, true])('continues after a completed compaction beyond the first message page (HTTP fallback: %s)', async (fallback) => {
+    const messages = Array.from({ length: 42 }, (_, index) => ({
+      id: `msg_${String(index).padStart(3, '0')}`,
+      type: index === 41 ? 'compaction' : index % 2 ? 'user' : 'assistant',
+      time: index === 41 ? { created: index + 1 } : { created: index + 1, completed: index + 2 },
+      model: { providerID: 'p', id: 'm' },
+      agent: 'build',
+      ...(index === 41 ? { status: 'completed', summary: 'Work remains' } : { text: 'Working' }),
+    }));
+    const fixture = makeFetch({ messages, liveStatus: 'idle' });
+    const runtime = makeRuntime();
+    try {
+      await withFetch(async (input, init) => {
+        const url = new URL(String(input));
+        if (pathEndsWith(url.pathname, '/session/ses-goal/message')) {
+          if (fallback && url.pathname.startsWith('/api/')) return jsonResponse({ error: 'unavailable' }, 503);
+          const ordered = url.searchParams.get('order') === 'desc' ? [...messages].reverse() : messages;
+          return jsonResponse({ data: ordered.slice(0, Number(url.searchParams.get('limit') || 40)), cursor: {} });
+        }
+        return fixture.fetch(input, init);
+      }, async () => runtime.runTick('ses-goal', '/repo'));
+      expect(fixture.calls.prompt).toBe(1);
+    } finally {
+      runtime.stop();
+    }
+  });
+
   it('dispatches v2 session.prompt with stable continuation id and metadata', async () => {
     const promptBodies = [];
     const messages = [
@@ -291,7 +318,7 @@ describe('session-goal continuation delivery', () => {
         return jsonResponse({ data: {} });
       }
       if (pathEndsWith(reqPath, '/session/ses-goal/message')) {
-        return jsonResponse({ data: messages, cursor: {} });
+        return jsonResponse({ data: new URL(url).searchParams.get('order') === 'desc' ? [...messages].reverse() : messages, cursor: {} });
       }
       if (pathEndsWith(reqPath, '/session/ses-goal') && !reqPath.includes('/message')) {
         if (init.method === 'PATCH' && init.body) {
@@ -984,7 +1011,9 @@ describe('session-goal runtime — pause / audit / dispatch boundary', () => {
         const body = Array.isArray(messages)
           ? { data: messages, cursor: {} }
           : messages;
-        return jsonResponse(body);
+        return jsonResponse(new URL(String(input)).searchParams.get('order') === 'desc'
+          ? { ...body, data: [...body.data].reverse() }
+          : body);
       }
       if (pathEndsWith(reqPath, '/session/ses-goal')) {
         if (init.method === 'PATCH') {

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

@@ -50,18 +50,21 @@ extension-only VS Code retains the limitation below.
       assistant reply run concurrently. Generation publishes `isGenerating` via
       the existing Host metadata path, then the final title through `session.updated`.
       Later user admissions/idle events do not regenerate the initial title.
-      The legacy first-idle edge remains a fallback when no admission was observed.
-      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 `session.created` was missed, the admission's session read recovers
+       an empty/default title with no previous auto-title metadata and starts
+       immediately. The legacy first-idle edge remains a fallback when no
+       admission was observed.
+       A fork title (`(fork #n)`) refreshes on its first newly-admitted user
+       message, bypassing inherited title metadata and throttle without waiting
+       for the assistant. Legacy message-only events retain the idle fallback.
      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.
+      the fork time), so the first-send 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
-      ordinary already-armed timer; an admitted first-title timer is exempt.
+       ordinary already-armed timer; admitted initial/fork-title timers are exempt.
      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).
@@ -141,6 +144,13 @@ auto updates for that session.
 Title language follows the user's real message text. Assistant responses, tool
 output, and transcript labels provide context without selecting the title language.
 
+Attachments do not gate title generation. Admission retains user text plus at
+most eight bounded filename/MIME descriptors, never attachment bytes or URLs.
+Attachment-only messages also start generation; the text-only summary model can
+name the attachment subject from those descriptors, but is explicitly told that
+file contents are not included. Transcript-based/manual generation uses the
+same file descriptors. This does not perform image recognition or file parsing.
+
 - Lives in the web server, so VS Code (extension-only) does not generate
   refreshes; it still receives `session.updated` title changes produced by a
   web/desktop instance of the same OpenCode server.

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

@@ -110,10 +110,12 @@ it('uses the real v2 client and publishes the generated title without another se
   }
 });
 
-it('starts the first title from admitted user text while the assistant is still running', async () => {
+it.each(['new', 'missed-create', 'fork', 'missed-fork-create'].flatMap((scenario) =>
+  ['text', 'text-and-file', 'file-only'].map((content) => ({ scenario, content })),
+))('starts the first title before assistant completion ($scenario, $content)', async ({ scenario, content }) => {
   vi.useFakeTimers();
   const session = {
-    id: 'ses_first', title: '', time: { created: 1, updated: 1 },
+    id: 'ses_first', title: scenario.includes('fork') ? 'Original (fork #1)' : '', time: { created: 1, updated: 1 },
     metadata: {},
   };
   let finishTitle;
@@ -135,26 +137,36 @@ it('starts the first title from admitted user text while the assistant is still
   });
   const emit = (type, data) => runtime.processPayload({ type, data, created: 1000, location: { directory: '/repo' } });
   try {
-    emit('session.created', { sessionID: session.id, location: { directory: '/repo' } });
+    if (!scenario.startsWith('missed')) {
+      emit('session.created', { sessionID: session.id, title: session.title, time: session.time, location: { directory: '/repo' } });
+    }
     emit('session.inbox.enqueued', { sessionID: session.id, inboxID: 'msg_synthetic', item: {
       type: 'synthetic', delivery: 'steer', payload: { text: 'Internal instructions' },
     } });
     await vi.runAllTimersAsync();
     expect(generate).not.toHaveBeenCalled();
     emit('session.inbox.enqueued', { sessionID: session.id, inboxID: 'msg_first', item: {
-      type: 'user', delivery: 'steer', payload: { text: 'Implement a session title generator' },
+      type: 'user', delivery: 'steer', payload: {
+        text: content === 'file-only' ? '' : 'Implement a session title generator',
+        ...(content !== 'text' ? { files: [{ name: 'title-bug.png', mime: 'image/png', source: { type: 'inline' }, data: 'YQ=='.repeat(100_000) }] } : {}),
+      },
     } });
     emit('session.execution.started', { sessionID: session.id });
     emit('session.status', { sessionID: session.id, status: { type: 'busy' } });
     await vi.runAllTimersAsync();
     expect(generate).toHaveBeenCalledTimes(1);
-    expect(generate.mock.calls[0][0].prompt).toContain('Implement a session title generator');
+    const prompt = generate.mock.calls[0][0].prompt;
+    if (content !== 'file-only') expect(prompt).toContain('Implement a session title generator');
+    if (content !== 'text') expect(prompt).toContain('title-bug.png');
+    expect(prompt).not.toContain('YQ==');
+    expect(prompt.length).toBeLessThan(4000);
     expect(session.metadata.openchamber?.titleRefresh?.isGenerating).toBe(true);
     expect(access.messages).not.toHaveBeenCalled();
     finishTitle({ text: 'Session titles', providerID: 'test', modelID: 'test' });
     await vi.runAllTimersAsync();
     expect(session.title).toBe('Session titles');
     expect(session.metadata.openchamber.titleRefresh.isGenerating).toBeUndefined();
+    expect(access.messages).not.toHaveBeenCalled();
     emit('session.execution.succeeded', { sessionID: session.id });
     emit('session.inbox.enqueued', { sessionID: session.id, inboxID: 'msg_second', item: {
       type: 'user', delivery: 'steer', payload: { text: 'Follow up on the implementation' },

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

@@ -1,7 +1,7 @@
 // Session title refresh: regenerate the sidebar title from the conversation's
 // MAIN SUBJECT (overall feature / goal), not just the last wrap-up utterance.
 // OpenCode only titles once from the first user message. Auto refresh is sparse
-// for title stability: first idle of a new session, first newly-sent reply on a
+// for title stability: first user admission of a new session, first send on a
 // fork, plus explicit smart-title / forced refresh. Continuing the same work
 // should keep naming the thing being done — not "commit and push". This
 // watcher throttles to at most one refresh per session every TITLE_THROTTLE_MS
@@ -201,13 +201,22 @@ const extractUserMessage = (payload) => {
     const item = properties.item;
     if (typeof properties.sessionID !== 'string' || item?.type !== 'user') return null;
     const text = typeof item.payload?.text === 'string' ? item.payload.text.slice(0, TRANSCRIPT_USER_CHAR_LIMIT) : '';
+    const files = Array.isArray(item.payload?.files) ? item.payload.files.slice(0, 8) : [];
+    const parts = [
+      ...(text.trim() ? [{ type: 'text', text }] : []),
+      ...files.filter((file) => file && typeof file === 'object').map((file) => ({
+        type: 'file',
+        filename: typeof file.name === 'string' ? file.name.slice(0, 200) : '',
+        mime: typeof file.mime === 'string' ? file.mime.slice(0, 100) : '',
+      })),
+    ];
     return {
       sessionId: properties.sessionID,
       createdAt: payload.created ?? 0,
       directory: payload.location?.directory ?? '',
-      initialRecord: text.trim() ? {
+      initialRecord: parts.length ? {
         info: { id: properties.inboxID, role: 'user' },
-        parts: [{ type: 'text', text }],
+        parts,
       } : null,
     };
   }
@@ -230,7 +239,13 @@ const messagePartsToText = (message) => {
     ? TRANSCRIPT_ASSISTANT_CHAR_LIMIT
     : TRANSCRIPT_USER_CHAR_LIMIT;
   return parts
-    .map((part) => (part?.type === 'text' && typeof part.text === 'string' ? part.text : ''))
+    .map((part) => {
+      if (part?.type === 'text' && typeof part.text === 'string') return part.text;
+      if (part?.type !== 'file') return '';
+      const filename = typeof part.filename === 'string' ? part.filename.slice(0, 200) : '';
+      const mime = typeof part.mime === 'string' ? part.mime.slice(0, 100) : '';
+      return `[Attachment: ${filename || mime || 'file'}${filename && mime ? ` (${mime})` : ''}; contents not included]`;
+    })
     .filter(Boolean)
     .join('\n')
     .slice(0, charLimit);
@@ -495,7 +510,7 @@ export const createSessionTitleRuntime = ({
     });
   };
 
-  const recordUserActivity = async (sessionId, directory, createdAt) => {
+  const recordUserActivity = async (sessionId, directory, createdAt, initialRecord) => {
     if (!Number.isFinite(createdAt) || createdAt <= 0) return;
     const session = await openCodeFetch(`/session/${encodeURIComponent(sessionId)}`, { directory })
       .catch(() => null);
@@ -508,7 +523,7 @@ export const createSessionTitleRuntime = ({
     // 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
+    // first admission can trigger the 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);
@@ -526,6 +541,26 @@ export const createSessionTitleRuntime = ({
       });
     }
 
+    // Recover first-send admission even when session.created was missed.
+    // Use the admitted text: the message projection may not exist yet.
+    if (initialRecord && !stopped && !inflight.has(sessionId) && !initialRefreshes.has(sessionId)
+      && !forkFirstRefreshes.has(sessionId) && !session.parentID && !isSystemOwnedSession(session)) {
+      const pendingFork = forkFirstSendPending.get(sessionId);
+      const firstForkSend = pendingFork && createdAt > pendingFork.createdAt;
+      const untitled = !session.title || isDefaultSessionTitle(session.title);
+      if (firstForkSend || (untitled && !meta.generatedAt && !meta.lastAutoTitle)) {
+        newSessions.delete(sessionId);
+        if (firstForkSend) {
+          forkFirstSendPending.delete(sessionId);
+          forkFirstRefreshes.add(sessionId);
+        } else {
+          initialRefreshes.add(sessionId);
+        }
+        initialUserMessages.set(sessionId, initialRecord);
+        armTimer(sessionId, directory, 0);
+      }
+    }
+
     const previous = Number(meta.titleRefresh.activityUpdatedAt);
     const activityUpdatedAt = Number.isFinite(previous) ? Math.max(previous, createdAt) : createdAt;
     if (activityUpdatedAt === previous) return;
@@ -683,7 +718,7 @@ export const createSessionTitleRuntime = ({
       return;
     }
 
-    const latestMessages = await fetchRecentMessages(sessionId, directory);
+    const latestMessages = initialUserMessage ? null : await fetchRecentMessages(sessionId, directory);
     const latestAssistantId = (() => {
       if (!latestMessages) return null;
       for (let i = latestMessages.length - 1; i >= 0; i -= 1) {
@@ -777,7 +812,7 @@ export const createSessionTitleRuntime = ({
           initialRefreshes.add(status.sessionId);
           armTimer(status.sessionId, status.directory || directoryHint, 0);
         }
-      } else if (!initialRefreshes.has(status.sessionId)) {
+      } else if (!initialRefreshes.has(status.sessionId) && !forkFirstRefreshes.has(status.sessionId)) {
         clearTimer(status.sessionId);
       }
       return;
@@ -797,6 +832,7 @@ export const createSessionTitleRuntime = ({
         userMessage.sessionId,
         userMessage.directory || directoryHint,
         userMessage.createdAt,
+        userMessage.initialRecord,
       ).catch((error) => {
         console.warn('[session-title] failed to record user activity:', error?.message || error);
       });
@@ -804,7 +840,7 @@ export const createSessionTitleRuntime = ({
       // session settles. Only a message created after the timer was armed
       // means the user actually moved on.
       const armed = timers.get(userMessage.sessionId);
-      if (armed && !initialRefreshes.has(userMessage.sessionId) && userMessage.createdAt >= armed.armedAt) {
+      if (armed && !initialRefreshes.has(userMessage.sessionId) && !forkFirstRefreshes.has(userMessage.sessionId) && userMessage.createdAt >= armed.armedAt) {
         clearTimer(userMessage.sessionId);
       }
     }