@openchambery/web 1.18.2-beta.2 → 1.18.2-beta.21

package/server/lib/opencode/settings-runtime.js

@@ -39,9 +39,41 @@ export const createSettingsRuntime = (deps) => {
     normalizeStringArray,
     formatSettingsResponse,
     resolveDirectoryCandidate,
+    /**
+     * Optional late-bound exclusive runner (Electron injects after startWebUiServer).
+     * May be a function returning the runner, or the runner itself.
+     */
+    getRunExclusivePersist,
+    runExclusivePersist: initialRunExclusivePersist,
   } = deps;
 
   let persistSettingsLock = Promise.resolve();
+  let runExclusivePersist = typeof initialRunExclusivePersist === 'function'
+    ? initialRunExclusivePersist
+    : null;
+
+  const resolveRunExclusivePersist = () => {
+    if (typeof getRunExclusivePersist === 'function') {
+      const resolved = getRunExclusivePersist();
+      if (typeof resolved === 'function') return resolved;
+    }
+    return typeof runExclusivePersist === 'function' ? runExclusivePersist : null;
+  };
+
+  const runPersistedWrite = (work) => {
+    const external = resolveRunExclusivePersist();
+    if (external) {
+      return external(work);
+    }
+    const next = persistSettingsLock.then(async () => work());
+    // Keep the chain alive even if one writer throws.
+    persistSettingsLock = next.catch(() => {});
+    return next;
+  };
+
+  const setRunExclusivePersist = (fn) => {
+    runExclusivePersist = typeof fn === 'function' ? fn : null;
+  };
 
   // Orphan recovery is a one-shot best-effort scan: when orphans can't be
   // matched on first pass they stay on disk and every subsequent settings
@@ -495,7 +527,7 @@ export const createSettingsRuntime = (deps) => {
     await fsPromises.rm(tmp, { force: true });
   };
 
-  const writeSettingsToDisk = async (settings) => {
+  const writeSettingsToDiskUnlocked = async (settings) => {
     try {
       await fsPromises.mkdir(path.dirname(SETTINGS_FILE_PATH), { recursive: true });
       // Atomic write: Electron main and ssh-manager read this file via plain
@@ -511,6 +543,8 @@ export const createSettingsRuntime = (deps) => {
     }
   };
 
+  const writeSettingsToDisk = async (settings) => runPersistedWrite(() => writeSettingsToDiskUnlocked(settings));
+
   const validateProjectEntries = async (projects) => {
     if (!Array.isArray(projects)) {
       return [];
@@ -778,67 +812,63 @@ export const createSettingsRuntime = (deps) => {
     const migration7 = migrateSettingsRemoveApprovedDirectories(migration6.settings);
     const migration8 = migrateSettingsCompactChatDefaults(migration7.settings);
     if (migration1.changed || migration2.changed || migration3.changed || migration4.changed || migration5.changed || migration6.changed || migration7.changed || migration8.changed) {
-      await writeSettingsToDisk(migration8.settings);
+      await runPersistedWrite(() => writeSettingsToDiskUnlocked(migration8.settings));
     }
     return migration8.settings;
   };
 
-  const persistSettings = async (changes) => {
-    persistSettingsLock = persistSettingsLock.then(async () => {
-      // Log field names only — changes can carry credentials (UI password,
-      // client tokens) that must never reach the log file.
-      console.log('[persistSettings] Updating fields:', Object.keys(changes || {}).join(', ') || '(none)');
-      const current = await readSettingsFromDisk();
-      const sanitized = sanitizeSettingsUpdate(changes);
-      let next = mergePersistedSettings(current, sanitized);
-
-      const normalizedState = normalizeSettingsPaths(next);
-      if (normalizedState.changed) {
-        next = normalizedState.settings;
-      }
+  const persistSettings = async (changes) => runPersistedWrite(async () => {
+    // Log field names only — changes can carry credentials (UI password,
+    // client tokens) that must never reach the log file.
+    console.log('[persistSettings] Updating fields:', Object.keys(changes || {}).join(', ') || '(none)');
+    const current = await readSettingsFromDisk();
+    const sanitized = sanitizeSettingsUpdate(changes);
+    let next = mergePersistedSettings(current, sanitized);
 
-      const deterministicProjectIdMigration = await migrateSettingsToDeterministicProjectIds(next);
-      if (deterministicProjectIdMigration.changed) {
-        next = deterministicProjectIdMigration.settings;
-      }
+    const normalizedState = normalizeSettingsPaths(next);
+    if (normalizedState.changed) {
+      next = normalizedState.settings;
+    }
 
-      const approvedDirectoriesMigration = migrateSettingsRemoveApprovedDirectories(next);
-      if (approvedDirectoriesMigration.changed) {
-        next = approvedDirectoriesMigration.settings;
-      }
+    const deterministicProjectIdMigration = await migrateSettingsToDeterministicProjectIds(next);
+    if (deterministicProjectIdMigration.changed) {
+      next = deterministicProjectIdMigration.settings;
+    }
 
-      // Ensure marker + new defaults exist before the first settings write lands.
-      const compactChatDefaultsMigration = migrateSettingsCompactChatDefaults(next);
-      if (compactChatDefaultsMigration.changed) {
-        next = compactChatDefaultsMigration.settings;
-      }
+    const approvedDirectoriesMigration = migrateSettingsRemoveApprovedDirectories(next);
+    if (approvedDirectoriesMigration.changed) {
+      next = approvedDirectoriesMigration.settings;
+    }
 
-      // Validating project paths hits the filesystem for every entry, so only
-      // do it when the incoming update actually touches the projects list —
-      // not on every theme/window-state/etc. save.
-      if (Object.prototype.hasOwnProperty.call(sanitized, 'projects') && Array.isArray(next.projects)) {
-        const validated = await validateProjectEntries(next.projects);
-        next = { ...next, projects: validated };
-      }
+    // Ensure marker + new defaults exist before the first settings write lands.
+    const compactChatDefaultsMigration = migrateSettingsCompactChatDefaults(next);
+    if (compactChatDefaultsMigration.changed) {
+      next = compactChatDefaultsMigration.settings;
+    }
 
-      if (Array.isArray(next.projects) && next.projects.length > 0) {
-        const activeId = typeof next.activeProjectId === 'string' ? next.activeProjectId : '';
-        const active = next.projects.find((project) => project.id === activeId) || null;
-        if (!active) {
-          console.log(`[persistSettings] Active project ID ${activeId} not found, switching to ${next.projects[0].id}`);
-          next = { ...next, activeProjectId: next.projects[0].id };
-        }
-      } else if (next.activeProjectId) {
-        console.log(`[persistSettings] No projects found, clearing activeProjectId ${next.activeProjectId}`);
-        next = { ...next, activeProjectId: undefined };
-      }
+    // Validating project paths hits the filesystem for every entry, so only
+    // do it when the incoming update actually touches the projects list —
+    // not on every theme/window-state/etc. save.
+    if (Object.prototype.hasOwnProperty.call(sanitized, 'projects') && Array.isArray(next.projects)) {
+      const validated = await validateProjectEntries(next.projects);
+      next = { ...next, projects: validated };
+    }
 
-      await writeSettingsToDisk(next);
-      return formatSettingsResponse(next);
-    });
+    if (Array.isArray(next.projects) && next.projects.length > 0) {
+      const activeId = typeof next.activeProjectId === 'string' ? next.activeProjectId : '';
+      const active = next.projects.find((project) => project.id === activeId) || null;
+      if (!active) {
+        console.log(`[persistSettings] Active project ID ${activeId} not found, switching to ${next.projects[0].id}`);
+        next = { ...next, activeProjectId: next.projects[0].id };
+      }
+    } else if (next.activeProjectId) {
+      console.log(`[persistSettings] No projects found, clearing activeProjectId ${next.activeProjectId}`);
+      next = { ...next, activeProjectId: undefined };
+    }
 
-    return persistSettingsLock;
-  };
+    await writeSettingsToDiskUnlocked(next);
+    return formatSettingsResponse(next);
+  });
 
   return {
     readSettingsFromDisk,
@@ -846,5 +876,6 @@ export const createSettingsRuntime = (deps) => {
     readSettingsFromDiskMigrated,
     writeSettingsToDisk,
     persistSettings,
+    setRunExclusivePersist,
   };
 };

package/server/lib/opencode/settings-runtime.test.js

@@ -190,6 +190,48 @@ describe('settings runtime', () => {
     }
   });
 
+  it('joins an external exclusive persist runner when provided', async () => {
+    const { runtime, settingsFilePath, cleanup } = await createRuntime();
+    try {
+      const order = [];
+      let releaseOuter;
+      const outerGate = new Promise((resolve) => {
+        releaseOuter = resolve;
+      });
+
+      runtime.setRunExclusivePersist(async (work) => {
+        order.push('lock-enter');
+        const result = await work();
+        order.push('lock-exit');
+        return result;
+      });
+
+      const pending = (async () => {
+        order.push('outer-start');
+        await outerGate;
+        order.push('outer-before-write');
+        await runtime.writeSettingsToDisk({ theme: 'external' });
+        order.push('outer-after-write');
+      })();
+
+      // Without awaiting the outer gate, ensure the lock wrapper is the one used.
+      releaseOuter();
+      await pending;
+      expect(order).toEqual([
+        'outer-start',
+        'outer-before-write',
+        'lock-enter',
+        'lock-exit',
+        'outer-after-write',
+      ]);
+      await expect(fsPromises.readFile(settingsFilePath, 'utf8')).resolves.toBe(
+        JSON.stringify({ theme: 'external' }, null, 2),
+      );
+    } finally {
+      await cleanup();
+    }
+  });
+
   it.skipIf(process.platform !== 'win32')('falls back when Windows blocks atomic settings replacement', async () => {
     const tempRoot = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'oc-settings-runtime-'));
     const settingsFilePath = path.join(tempRoot, 'settings.json');

package/server/lib/relay/DOCUMENTATION.md

@@ -50,7 +50,7 @@ The host dispatcher restricts tunneled traffic to explicit path allowlists (one
 Private Relay is transparent for allowlisted HTTP paths, so most “works on LAN / Desktop, empty on mobile Relay” bugs are Host routing or client transport-identity mistakes rather than Relay framing bugs:
 
 - **Same path, real Host route required.** Clients call the ordinary `/api/...` path through the tunnel. If that route is missing on the Host process currently holding the relay claim (wrong git worktree, stale packaged Desktop build, or a backend that never registered the OpenChamber route before the OpenCode proxy/SPA fallback), the tunnel still returns HTTP 200 with SPA HTML or proxied OpenCode content. Symptom: chat and status work, Provider/model catalog does not.
-- **HTTP allowlist is prefix-based for `/api/`.** New REST/SSE APIs under `/api/` do not need a tunnel-host allowlist edit. New **WebSocket** paths still need both `ALLOWED_WS_PATHS` and `isUrlAuthWebSocketPath` (see the `relay-transport` skill).
+- **HTTP allowlist is prefix-based for `/api/`.** New REST/SSE APIs under `/api/` do not need a tunnel-host allowlist edit. New **WebSocket** paths still need both `ALLOWED_WS_PATHS` and `isUrlAuthWebSocketPath` (see the `relay-transport` skill). Config sync (`/api/openchamber/config-sync/*`, ticket 05/06) therefore works over Relay without a tunnel-host allowlist change; identity and credential grants remain endpoint concerns (`relay:<serverId>`, pairing-settings / inbound host grant).
 - **Transport identity ≠ runtime key.** After LAN⇄relay swaps, UI catalog loaders commit only when `useConfigStore.catalogTransportIdentity` matches `getRuntimeTransportIdentity()`. `runtimeEndpointReset.ts` must write that transport fingerprint on both full endpoint reset and in-place transport reconnect. Writing `runtimeKey` instead leaves Providers empty because the stable device/instance id is shared across LAN and relay.
 - **Safe catalog projection stays Host-owned.** Provider credentials never cross the browser; Relay only carries the already-allowlisted `GET /api/config/catalog/providers` JSON. Keep Host projection, client parser bounds, and `partial` rules in sync (empty `release_date` is absent, not partial).
 

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

@@ -13,14 +13,20 @@ newest 20 root-session summaries per runtime and directory. It never stores
 messages, attachments, permissions, provider data, or model metadata.
 Sessions titled `smartfetch-secondary` are temporary SmartFetch model calls;
 the index excludes them from every snapshot and clears prior summaries when a
-matching session update arrives. System-owned sessions are excluded by
-authoritative metadata only: a non-empty
-`metadata.openchamber.assistant.assistantID` or
-`metadata.openchamber.scheduledTask.taskID`. Title prefixes are human labels and
-never participate in this filter. Metadata is the ownership/isolation signal;
-`time.archived` is archive state; titles are for recognition. The index does
+  matching session update arrives. System-owned sessions are excluded by
+  authoritative metadata only: a non-empty
+  `metadata.openchamber.assistant.assistantID`,
+  `metadata.openchamber.scheduledTask.taskID`, or
+  `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
 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
+`publishChange()` so revision tips broadcast `openchamber:session-index-changed`.
 
 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/routes.js

@@ -62,4 +62,38 @@ export const registerSessionIndexRoutes = (app, { sessionIndexService, sessionIn
     }
     res.json({ available: true, session: hit });
   });
+
+  app.post('/api/openchamber/session-index/session/:id/pin', (req, res) => {
+    if (!sessionIndexService) return unsupported(res);
+    if (typeof sessionIndexService.setPinned !== 'function') {
+      return res.status(501).json({ error: 'Session pin is unavailable' });
+    }
+    const sessionId = req.params.id;
+    if (typeof sessionId !== 'string' || !sessionId.trim()) {
+      return res.status(400).json({ error: 'sessionId is required' });
+    }
+    const changed = sessionIndexService.setPinned(sessionId.trim());
+    if (!changed) {
+      return res.status(404).json({ error: 'session_not_found', sessionId: sessionId.trim() });
+    }
+    sessionIndexSyncRuntime?.publishChange?.();
+    res.status(204).end();
+  });
+
+  app.delete('/api/openchamber/session-index/session/:id/pin', (req, res) => {
+    if (!sessionIndexService) return unsupported(res);
+    if (typeof sessionIndexService.clearPinned !== 'function') {
+      return res.status(501).json({ error: 'Session unpin is unavailable' });
+    }
+    const sessionId = req.params.id;
+    if (typeof sessionId !== 'string' || !sessionId.trim()) {
+      return res.status(400).json({ error: 'sessionId is required' });
+    }
+    const changed = sessionIndexService.clearPinned(sessionId.trim());
+    if (!changed) {
+      return res.status(404).json({ error: 'session_not_found', sessionId: sessionId.trim() });
+    }
+    sessionIndexSyncRuntime?.publishChange?.();
+    res.status(204).end();
+  });
 };

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

@@ -137,4 +137,80 @@ describe('session index routes', () => {
     expect(res.statusCode).toBe(404);
     expect(res.body).toMatchObject({ error: 'session_not_found' });
   });
+
+  it('pins a session and publishes a session-index change', () => {
+    const { app, route } = registry();
+    const setPinned = vi.fn(() => true);
+    const publishChange = vi.fn();
+    registerSessionIndexRoutes(app, {
+      sessionIndexService: {
+        snapshot: () => ({ directories: [] }),
+        setPinned,
+      },
+      sessionIndexSyncRuntime: { publishChange },
+    });
+    const res = response();
+
+    route('POST', '/api/openchamber/session-index/session/:id/pin')(
+      { params: { id: 'ses_abc' } },
+      res,
+    );
+
+    expect(setPinned).toHaveBeenCalledWith('ses_abc');
+    expect(publishChange).toHaveBeenCalledTimes(1);
+    expect(res.statusCode).toBe(204);
+  });
+
+  it('unpins a session and publishes a session-index change', () => {
+    const { app, route } = registry();
+    const clearPinned = vi.fn(() => true);
+    const publishChange = vi.fn();
+    registerSessionIndexRoutes(app, {
+      sessionIndexService: {
+        snapshot: () => ({ directories: [] }),
+        clearPinned,
+      },
+      sessionIndexSyncRuntime: { publishChange },
+    });
+    const res = response();
+
+    route('DELETE', '/api/openchamber/session-index/session/:id/pin')(
+      { params: { id: 'ses_abc' } },
+      res,
+    );
+
+    expect(clearPinned).toHaveBeenCalledWith('ses_abc');
+    expect(publishChange).toHaveBeenCalledTimes(1);
+    expect(res.statusCode).toBe(204);
+  });
+
+  it('returns 404 for pin and unpin when the session is missing', () => {
+    const { app, route } = registry();
+    const publishChange = vi.fn();
+    registerSessionIndexRoutes(app, {
+      sessionIndexService: {
+        snapshot: () => ({ directories: [] }),
+        setPinned: () => false,
+        clearPinned: () => false,
+      },
+      sessionIndexSyncRuntime: { publishChange },
+    });
+
+    const pinRes = response();
+    route('POST', '/api/openchamber/session-index/session/:id/pin')(
+      { params: { id: 'ses_missing' } },
+      pinRes,
+    );
+    expect(pinRes.statusCode).toBe(404);
+    expect(pinRes.body).toMatchObject({ error: 'session_not_found' });
+
+    const unpinRes = response();
+    route('DELETE', '/api/openchamber/session-index/session/:id/pin')(
+      { params: { id: 'ses_missing' } },
+      unpinRes,
+    );
+    expect(unpinRes.statusCode).toBe(404);
+    expect(unpinRes.body).toMatchObject({ error: 'session_not_found' });
+    expect(publishChange).not.toHaveBeenCalled();
+  });
 });

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

@@ -15,6 +15,7 @@ const isSystemSession = (session) => {
   if (!openchamber || typeof openchamber !== 'object') return false;
   if (nonEmptySystemID(openchamber.assistant?.assistantID)) return true;
   if (nonEmptySystemID(openchamber.scheduledTask?.taskID)) return true;
+  if (nonEmptySystemID(openchamber.smallModel?.purpose)) return true;
   return false;
 };
 
@@ -116,6 +117,7 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
       updated_at INTEGER NOT NULL,
       activity_updated_at INTEGER NOT NULL,
       archived_at INTEGER NOT NULL DEFAULT 0,
+      pinned_at INTEGER,
       status TEXT,
       status_changed_at INTEGER NOT NULL DEFAULT 0,
       parent_id TEXT,
@@ -139,6 +141,12 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     CREATE INDEX IF NOT EXISTS session_child_parent
       ON session_child(runtime_key, directory, parent_id);
   `);
+  const sessionSummaryColumns = new Set(
+    db.prepare("SELECT name FROM pragma_table_info('session_summary')").all().map((column) => column.name),
+  );
+  if (!sessionSummaryColumns.has('pinned_at')) {
+    db.exec('ALTER TABLE session_summary ADD COLUMN pinned_at INTEGER');
+  }
   db.prepare('INSERT OR REPLACE INTO session_index_meta(key, value) VALUES (?, ?)')
     .run('schema_version', String(SCHEMA_VERSION));
 
@@ -165,7 +173,7 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
   const deleteDirectoryRows = db.prepare('DELETE FROM session_summary WHERE runtime_key = ? AND directory = ?');
   const existingSummaryState = db.prepare(`
     SELECT session_id, has_children AS hasChildren, activity_updated_at AS activityUpdatedAt,
-      status, status_changed_at AS statusChangedAt
+      status, status_changed_at AS statusChangedAt, pinned_at AS pinnedAt
     FROM session_summary WHERE runtime_key = ? AND directory = ?
   `);
   const readSummary = db.prepare(`
@@ -183,8 +191,8 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     LIMIT 1 OFFSET ?
   `);
   const insertSummary = db.prepare(`
-    INSERT INTO session_summary(runtime_key, directory, session_id, title, created_at, updated_at, activity_updated_at, archived_at, status, status_changed_at, parent_id, has_children, assistant_id, assistant_name)
-    VALUES (@runtimeKey, @directory, @id, @title, @createdAt, @updatedAt, @activityUpdatedAt, @archivedAt, @status, @statusChangedAt, @parentID, @hasChildren, @assistantID, @assistantName)
+    INSERT INTO session_summary(runtime_key, directory, session_id, title, created_at, updated_at, activity_updated_at, archived_at, pinned_at, status, status_changed_at, parent_id, has_children, assistant_id, assistant_name)
+    VALUES (@runtimeKey, @directory, @id, @title, @createdAt, @updatedAt, @activityUpdatedAt, @archivedAt, @pinnedAt, @status, @statusChangedAt, @parentID, @hasChildren, @assistantID, @assistantName)
   `);
   const upsertSummary = db.prepare(`
     INSERT INTO session_summary(runtime_key, directory, session_id, title, created_at, updated_at, activity_updated_at, archived_at, status, status_changed_at, parent_id, has_children, assistant_id, assistant_name)
@@ -259,6 +267,7 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
       insertSummary.run({
         ...summary,
         activityUpdatedAt: Math.max(summary.activityUpdatedAt, toTimestamp(previous?.activityUpdatedAt)),
+        pinnedAt: previous?.pinnedAt != null ? toTimestamp(previous.pinnedAt) : null,
         status: typeof previous?.status === 'string' ? previous.status : null,
         statusChangedAt: toTimestamp(previous?.statusChangedAt),
         hasChildren: toBooleanInt(summary.hasChildren ?? Boolean(previous?.hasChildren)),
@@ -364,6 +373,7 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
       sessions: db.prepare(`
         SELECT session_id AS id, title, created_at AS createdAt, updated_at AS updatedAt,
           activity_updated_at AS activityUpdatedAt, archived_at AS archivedAt,
+          pinned_at AS pinnedAt,
           status, status_changed_at AS statusChangedAt, parent_id AS parentID,
           has_children AS hasChildren, assistant_id AS assistantID, assistant_name AS assistantName
         FROM session_summary WHERE runtime_key = ? AND directory = ?
@@ -373,7 +383,12 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
           id: session.id,
           title: session.title,
           directory: directory.directory,
-          time: { created: session.createdAt, updated: session.updatedAt, ...(session.archivedAt ? { archived: session.archivedAt } : {}) },
+          time: {
+            created: session.createdAt,
+            updated: session.updatedAt,
+            ...(session.archivedAt ? { archived: session.archivedAt } : {}),
+            ...(session.pinnedAt ? { pinned: session.pinnedAt } : {}),
+          },
           metadata: {
             openchamber: {
               titleRefresh: { activityUpdatedAt: session.activityUpdatedAt },
@@ -465,6 +480,38 @@ 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);
+    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 replaceChildSessions = db.transaction((directory, parentSessionID, children) => {
     const normalizedDirectory = normalizeDirectory(directory);
     if (!normalizedDirectory || typeof parentSessionID !== 'string' || !parentSessionID) return false;
@@ -487,6 +534,8 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     upsertAndReportChange,
     touchActivity,
     updateStatus,
+    setPinned,
+    clearPinned,
     remove,
     findBySessionId,
     replaceChildSessions,

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

@@ -68,7 +68,7 @@ describe('Electron session index', () => {
     service.close();
   });
 
-  it('excludes Assistant and Scheduled system sessions from ordinary sidebar summaries', () => {
+  it('excludes Assistant, Scheduled, and smallModel system sessions from ordinary sidebar summaries', () => {
     const runtimeRef = { value: 'http://runtime-a.test' };
     const service = createService(runtimeRef);
     const assistantSession = {
@@ -79,11 +79,15 @@ describe('Electron session index', () => {
       ...session('ses_scheduled', 99),
       metadata: { openchamber: { scheduledTask: { taskID: 'task_1' } } },
     };
+    const smallModelSession = {
+      ...session('ses_small_model', 97),
+      metadata: { openchamber: { smallModel: { purpose: 'session-title' } } },
+    };
     const ordinary = session('ses_ordinary', 98);
 
     service.replaceDirectory({
       directory: '/repo',
-      sessions: [assistantSession, scheduledSession, ordinary],
+      sessions: [assistantSession, scheduledSession, smallModelSession, ordinary],
       cursor: null,
       hasMore: false,
     });
@@ -91,6 +95,7 @@ describe('Electron session index', () => {
 
     service.upsert(assistantSession);
     service.upsert(scheduledSession);
+    service.upsert(smallModelSession);
     expect(service.snapshot().directories[0].sessions.map((item) => item.id)).toEqual(['ses_ordinary']);
     service.close();
   });
@@ -318,4 +323,69 @@ describe('Electron session index', () => {
     expect(rebuilt.snapshot().directories).toEqual([]);
     rebuilt.close();
   });
+
+  it('exposes time.pinned in snapshots and clears it on unpin', () => {
+    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', 55)).toBe(true);
+    expect(service.snapshot().directories[0].sessions[0].time).toMatchObject({
+      created: 9,
+      updated: 10,
+      pinned: 55,
+    });
+
+    expect(service.clearPinned('ses_a')).toBe(true);
+    expect(service.snapshot().directories[0].sessions[0].time).toEqual({
+      created: 9,
+      updated: 10,
+    });
+    service.close();
+  });
+
+  it('rescues pinned_at across replaceDirectory rebuilds', () => {
+    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', 77)).toBe(true);
+
+    service.replaceDirectory({
+      directory: '/repo',
+      sessions: [session('ses_a', 20)],
+      cursor: null,
+      hasMore: false,
+      now: 2000,
+    });
+
+    expect(service.snapshot().directories[0].sessions[0].time).toMatchObject({
+      updated: 20,
+      pinned: 77,
+    });
+    service.close();
+  });
+
+  it('does not let live upsert overwrite pinned_at', () => {
+    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', 88)).toBe(true);
+
+    service.upsert(session('ses_a', 30));
+
+    expect(service.snapshot().directories[0].sessions[0].time.pinned).toBe(88);
+    service.close();
+  });
+
+  it('removes pinned rows when an archived upsert deletes the session', () => {
+    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', 99)).toBe(true);
+
+    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.clearPinned('ses_a')).toBe(false);
+    service.close();
+  });
 });