@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

package/server/lib/session-metadata/session-projection.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  extractSessionInfoFromPayload,
+  normalizeSessionEventType,
+  projectSessionLifecyclePayload,
+  resolveSessionDirectory,
+} from './session-projection.js';
+
+describe('session projection event shapes', () => {
+  it('normalizes version suffixes', () => {
+    expect(normalizeSessionEventType('session.updated.v2')).toBe('session.updated');
+    expect(normalizeSessionEventType('session.created')).toBe('session.created');
+  });
+
+  it('extracts info from properties.info and data.info', () => {
+    expect(extractSessionInfoFromPayload({
+      type: 'session.updated',
+      properties: { info: { id: 'ses_a' } },
+    })?.id).toBe('ses_a');
+    expect(extractSessionInfoFromPayload({
+      type: 'session.updated.v2',
+      data: { info: { id: 'ses_b' } },
+    })?.id).toBe('ses_b');
+  });
+
+  it('prefers location.directory', () => {
+    expect(resolveSessionDirectory({
+      location: { directory: '/loc' },
+      directory: '/legacy',
+    })).toBe('/loc');
+  });
+
+  it('projects GlobalEvent wrap and preserves envelope directory', () => {
+    const projected = projectSessionLifecyclePayload({
+      directory: '/repo',
+      payload: {
+        type: 'session.updated.v2',
+        data: {
+          info: {
+            id: 'ses_1',
+            time: { created: 1, updated: 2, archived: 50 },
+          },
+        },
+      },
+    }, () => ({ openchamber: { archive: { archivedAt: 99 } } }));
+
+    expect(projected.directory).toBe('/repo');
+    expect(projected.payload.type).toBe('session.updated.v2');
+    expect(projected.payload.data.info.time.archived).toBe(99);
+  });
+
+  it('returns null for lifecycle when hostReady is false', () => {
+    expect(projectSessionLifecyclePayload({
+      type: 'session.updated',
+      properties: { info: { id: 'ses_1', time: {} } },
+    }, () => null, { hostReady: false })).toBeNull();
+  });
+
+  it('leaves message events alone when hostReady is false', () => {
+    const msg = { type: 'message.updated', properties: { info: { role: 'user' } } };
+    expect(projectSessionLifecyclePayload(msg, () => null, { hostReady: false })).toBe(msg);
+  });
+});

package/server/lib/session-metadata/system-session.js

@@ -0,0 +1,55 @@
+/**
+ * Host-owned isolation markers for system sessions.
+ *
+ * Sidebar / session-index / notifications hide a session only when these
+ * fields are present. Title prefixes are labels and never ownership.
+ *
+ * Every system session creator (scheduled tasks, LLM attachment gateway,
+ * Assistant bindings) must persist the matching patch through the Host
+ * session-metadata store. OpenCode create-time `metadata` is a hint only.
+ */
+
+export const LLM_SESSION_PURPOSE = 'chat-completions';
+
+const nonEmpty = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
+
+export const buildScheduledTaskMetadata = ({ projectID, taskID, runID, name } = {}) => {
+  const id = nonEmpty(taskID);
+  if (!id) {
+    throw new Error('scheduled-task metadata requires taskID');
+  }
+  return {
+    openchamber: {
+      scheduledTask: {
+        taskID: id,
+        ...(nonEmpty(projectID) ? { projectID: nonEmpty(projectID) } : {}),
+        ...(nonEmpty(runID) ? { runID: nonEmpty(runID) } : {}),
+        ...(nonEmpty(name) ? { name: nonEmpty(name) } : {}),
+      },
+    },
+  };
+};
+
+export const buildLlmSessionMetadata = (purpose = LLM_SESSION_PURPOSE) => {
+  const resolved = nonEmpty(purpose) || LLM_SESSION_PURPOSE;
+  return {
+    openchamber: {
+      llm: { purpose: resolved },
+    },
+  };
+};
+
+export const buildAssistantSessionMetadata = ({ assistantID, name } = {}) => {
+  const id = nonEmpty(assistantID);
+  if (!id) {
+    throw new Error('assistant session metadata requires assistantID');
+  }
+  return {
+    openchamber: {
+      assistant: {
+        assistantID: id,
+        ...(nonEmpty(name) ? { name: nonEmpty(name) } : {}),
+      },
+    },
+  };
+};

package/server/lib/session-metadata/system-session.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import {
+  LLM_SESSION_PURPOSE,
+  buildAssistantSessionMetadata,
+  buildLlmSessionMetadata,
+  buildScheduledTaskMetadata,
+} from './system-session.js';
+
+describe('system session metadata builders', () => {
+  it('builds scheduled-task isolation from a non-empty taskID', () => {
+    expect(buildScheduledTaskMetadata({
+      projectID: 'project-1',
+      taskID: 'task-1',
+      runID: 'run-1',
+      name: 'Morning Sync',
+    })).toEqual({
+      openchamber: {
+        scheduledTask: {
+          taskID: 'task-1',
+          projectID: 'project-1',
+          runID: 'run-1',
+          name: 'Morning Sync',
+        },
+      },
+    });
+  });
+
+  it('refuses scheduled-task metadata without taskID', () => {
+    expect(() => buildScheduledTaskMetadata({ projectID: 'project-1' })).toThrow(/taskID/);
+  });
+
+  it('builds llm isolation with the chat-completions purpose', () => {
+    expect(buildLlmSessionMetadata()).toEqual({
+      openchamber: { llm: { purpose: LLM_SESSION_PURPOSE } },
+    });
+    expect(buildLlmSessionMetadata('  ')).toEqual({
+      openchamber: { llm: { purpose: LLM_SESSION_PURPOSE } },
+    });
+  });
+
+  it('builds assistant isolation from a non-empty assistantID', () => {
+    expect(buildAssistantSessionMetadata({
+      assistantID: 'assistant_1',
+      name: 'Ops',
+    })).toEqual({
+      openchamber: {
+        assistant: { assistantID: 'assistant_1', name: 'Ops' },
+      },
+    });
+  });
+
+  it('refuses assistant metadata without assistantID', () => {
+    expect(() => buildAssistantSessionMetadata({ name: 'Ops' })).toThrow(/assistantID/);
+  });
+});

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

@@ -5,20 +5,53 @@ conversation's **main subject** (overall feature / goal) with the small model
 (`lib/small-model`), then PATCHes `title` plus `metadata.openchamber.titleRefresh`.
 
 OpenCode only auto-titles once from the first user message
-(`SessionPrompt.ensureTitle`). This module auto-refreshes sparsely (first idle
-of a new session, first newly-sent reply on a fork) and on explicit smart-title
+(`SessionPrompt.ensureTitle`). This module auto-refreshes sparsely (first user
+admission of a new session, first newly-sent reply on a fork) and on explicit smart-title
 requests, naming the durable work being done — not the last wrap-up utterance
 like "commit and push". Background auto refreshes still respect a 5-minute
 throttle (`TITLE_THROTTLE_MS`) when a refresh is armed.
 
 ## Flow
 
+### OpenCode 2 smart-title boundary
+
+Manual requests arrive as Host `openchamber:session-metadata` writes. The
+metadata route's committed-write callback explicitly notifies the title runtime;
+it must not rely on OpenCode echoing Host metadata as `session.updated`.
+`session-access.js` owns the production boundary: official client session reads
+and title updates, a bounded `message.list({ order: 'desc' })` page projected into
+chronological transcript records, and Host metadata reads/merge patches.
+Only changed `titleRefresh` fields are persisted. Transient fields are removed
+with RFC 7386 `null`, so `isGenerating` and `requestedAt` cannot survive a clear.
+Unrelated goal, archive, and ownership metadata is never replaced by a title read.
+
+After a successful title write or generation-state change, an authoritative full session row is published
+as `session.updated` and applied to the session index. Connected clients receive
+both loading metadata and the new title without reselecting the session. Neither
+event represents an execution-status transition: the original session's busy /
+retry status and subsequent execution events remain independently authoritative.
+Publishing the loading row also covers first-send admission arriving before the
+renderer inserts the new session: a metadata-only event would otherwise be ignored
+for that still-unknown row.
+This Host path serves web, Electron, and connected hosted/native mobile clients;
+extension-only VS Code retains the limitation below.
+
 1. `createSessionTitleRuntime` is a consumer of the server's global SSE
    fan-out (`index.js` → `globalMessageStreamHub.subscribeEvent`). 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
+   2. Auto title refresh is intentionally sparse (title stability first). A newly
+      observed root `session.created` generates its first title immediately on
+      the first native `session.inbox.enqueued` user item. Native `data` envelopes
+      are accepted alongside legacy `properties`. The admitted text is bounded
+      to the user-message limit and retained only until the generation starts;
+      it avoids a race with the not-yet-materialized message projection. Synthetic,
+      compaction, and move items cannot start this title. Busy/execution-start
+      events do not cancel this first-title timer: title generation and the main
+      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 the fork's `session.created` was lost (SSE reconnect gap, server or
@@ -27,8 +60,8 @@ throttle (`TITLE_THROTTLE_MS`) when a refresh is armed.
      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).
+      `busy`/`retry` status or a fresh user `message.updated` still clears an
+      ordinary already-armed timer; an admitted first-title timer is 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).

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

@@ -0,0 +1,167 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { createSessionTitleRuntime } from './runtime.js';
+import { mergeMetadataPatch } from '../session-metadata/session-metadata-store.js';
+import { createTitleSessionAccess } from './session-access.js';
+import { configureServerOpenCodeFetchGate } from '../opencode/server-opencode-fetch.js';
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+  configureServerOpenCodeFetchGate(null);
+});
+
+it.each([false, true])('runs a Host smart-title request and clears loading (model failure: %s)', async (fail) => {
+  vi.useFakeTimers();
+  const metadata = { openchamber: { titleRefresh: { lastAutoTitle: 'Original', requestedAt: 1000 } } };
+  const session = { id: 'ses_title', title: 'Original', directory: '/repo', metadata };
+  const updates = [];
+  const sessionAccess = {
+    get: vi.fn(async () => structuredClone(session)),
+    update: vi.fn(async (_id, _directory, patch) => {
+      if (patch.title) session.title = patch.title;
+      if (patch.metadata) session.metadata = mergeMetadataPatch(session.metadata, patch.metadata);
+      updates.push(structuredClone(session));
+    }),
+    messages: vi.fn(async () => [
+      { info: { id: 'u1', role: 'user' }, parts: [{ type: 'text', text: 'Implement a title refresh' }] },
+      { info: { id: 'a1', role: 'assistant' }, parts: [{ type: 'text', text: 'Done' }] },
+    ]),
+  };
+  const generate = vi.fn(async () => {
+    expect(session.metadata.openchamber.titleRefresh.isGenerating).toBe(true);
+    if (fail) throw new Error('title model unavailable');
+    return { text: 'Title refresh', providerID: 'test', modelID: 'test' };
+  });
+  const runtime = createSessionTitleRuntime({
+    sessionAccess,
+    buildOpenCodeUrl: (path) => `http://opencode${path}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    getSmallModelService: async () => ({ generateSmallModelText: generate }),
+    now: () => 1000,
+  });
+  try {
+    runtime.processPayload({ type: 'openchamber:session-metadata', properties: {
+      sessionID: session.id, directory: '/repo', metadata,
+    } });
+    await vi.runAllTimersAsync();
+    expect(generate).toHaveBeenCalledTimes(1);
+    expect(session.title).toBe(fail ? 'Original' : 'Title refresh');
+    if (fail) expect(session.metadata.openchamber.titleRefresh.lastError).toBe('title model unavailable');
+    expect(session.metadata.openchamber.titleRefresh.isGenerating).not.toBe(true);
+    expect(session.metadata.openchamber.titleRefresh.requestedAt).toBeUndefined();
+    expect(updates.some((row) => row.metadata.openchamber.titleRefresh.isGenerating)).toBe(true);
+  } finally {
+    runtime.stop();
+  }
+});
+
+it('uses the real v2 client and publishes the generated title without another session click', async () => {
+  vi.useFakeTimers();
+  configureServerOpenCodeFetchGate(null, { allowMissingContract: true });
+  let metadata = { openchamber: { titleRefresh: { lastAutoTitle: 'Original', requestedAt: 1000 } } };
+  const session = { id: 'ses_title', title: 'Original', location: { directory: '/repo' }, time: { created: 1, updated: 2 } };
+  const requests = [];
+  vi.stubGlobal('fetch', vi.fn(async (input, init) => {
+    const request = input instanceof Request ? input : new Request(input, init);
+    const url = new URL(request.url);
+    requests.push(`${request.method} ${url.pathname}`);
+    if (url.pathname.endsWith('/message')) {
+      expect(url.searchParams.get('order')).toBe('desc');
+      return Response.json({ data: [
+        { id: 'a1', type: 'assistant', content: [{ type: 'text', text: 'Done' }] },
+        { id: 'u1', type: 'user', text: 'Implement title refresh' },
+      ] });
+    }
+    if (request.method === 'PATCH') {
+      const body = await request.json();
+      expect(Object.keys(body)).toEqual(['title']);
+      session.title = body.title;
+      return new Response(null, { status: 204 });
+    }
+    return Response.json({ data: session });
+  }));
+  const events = [];
+  const access = createTitleSessionAccess({
+    buildOpenCodeUrl: (path) => `http://opencode${path}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    readSessionMetadata: async () => metadata,
+    persistSessionMetadata: async (_id, patch) => {
+      metadata = mergeMetadataPatch(metadata, patch);
+      events.push({ type: 'metadata', metadata: structuredClone(metadata) });
+    },
+    publishSession: (row) => events.push({ type: 'session', row }),
+  });
+  const runtime = createSessionTitleRuntime({
+    sessionAccess: access,
+    getSmallModelService: async () => ({ generateSmallModelText: async () => ({ text: 'Title refresh', providerID: 'test', modelID: 'test' }) }),
+    now: () => 1000,
+  });
+  try {
+    runtime.processPayload({ type: 'openchamber:session-metadata', properties: {
+      sessionID: session.id, metadata, directory: '/repo',
+    } });
+    await vi.runAllTimersAsync();
+    expect(events.some((event) => event.metadata?.openchamber?.titleRefresh?.isGenerating === true)).toBe(true);
+    expect(events.at(-1)).toMatchObject({ type: 'session', row: { title: 'Title refresh', directory: '/repo' } });
+    expect(metadata.openchamber.titleRefresh.isGenerating).toBeUndefined();
+    expect(requests).toContain('PATCH /api/session/ses_title');
+  } finally {
+    runtime.stop();
+  }
+});
+
+it('starts the first title from admitted user text while the assistant is still running', async () => {
+  vi.useFakeTimers();
+  const session = {
+    id: 'ses_first', title: '', time: { created: 1, updated: 1 },
+    metadata: {},
+  };
+  let finishTitle;
+  const generation = new Promise((resolve) => { finishTitle = resolve; });
+  const generate = vi.fn(() => generation);
+  const access = {
+    get: vi.fn(async () => structuredClone(session)),
+    update: vi.fn(async (_id, _directory, patch) => {
+      if (patch.metadata) session.metadata = mergeMetadataPatch(session.metadata, patch.metadata);
+      if (patch.title) session.title = patch.title;
+    }),
+    messages: vi.fn(async () => []),
+  };
+  const runtime = createSessionTitleRuntime({
+    sessionAccess: access,
+    getSmallModelService: async () => ({ generateSmallModelText: generate }),
+    isTitleRefreshEnabled: () => true,
+    now: () => 1000,
+  });
+  const emit = (type, data) => runtime.processPayload({ type, data, created: 1000, location: { directory: '/repo' } });
+  try {
+    emit('session.created', { sessionID: session.id, 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' },
+    } });
+    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');
+    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();
+    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' },
+    } });
+    await vi.runAllTimersAsync();
+    expect(generate).toHaveBeenCalledTimes(1);
+  } finally {
+    runtime.stop();
+  }
+});