@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/server/modules/database/repositories/sessions.db.ts

@@ -13,6 +13,8 @@ type SessionRow = {
   model: string | null;
   /** Reasoning effort this session runs with; NULL until the app records one. */
   effort: string | null;
+  /** The app session this one was branched from; NULL unless it is a fork. */
+  forked_from_session_id: string | null;
   isArchived: number;
   created_at: string;
   updated_at: string;
@@ -24,7 +26,7 @@ type RecentSessionsPage = {
 };
 
 const SESSION_ROW_COLUMNS =
-  'session_id, provider, provider_session_id, project_path, jsonl_path, custom_name, model, effort, isArchived, created_at, updated_at';
+  'session_id, provider, provider_session_id, project_path, jsonl_path, custom_name, model, effort, forked_from_session_id, isArchived, created_at, updated_at';
 
 const SQLITE_UTC_TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
 
@@ -111,7 +113,7 @@ export const sessionsDb = {
            updated_at = COALESCE(?, CURRENT_TIMESTAMP),
            project_path = ?,
            jsonl_path = ?,
-           isArchived = 0,
+           isArchived = CASE WHEN ? IS NULL OR julianday(?) > julianday(updated_at) THEN 0 ELSE isArchived END,
            custom_name = CASE
              WHEN session_id <> provider_session_id AND custom_name IS NOT NULL THEN custom_name
              ELSE COALESCE(?, custom_name)
@@ -122,6 +124,8 @@ export const sessionsDb = {
         updatedAtValue,
         normalizedProjectPath,
         jsonlPath ?? null,
+        updatedAtValue,
+        updatedAtValue,
         customName ?? null,
         existing.session_id
       );
@@ -141,7 +145,7 @@ export const sessionsDb = {
          updated_at = excluded.updated_at,
          project_path = excluded.project_path,
          jsonl_path = excluded.jsonl_path,
-         isArchived = 0,
+         isArchived = CASE WHEN ? IS NULL OR julianday(excluded.updated_at) > julianday(sessions.updated_at) THEN 0 ELSE sessions.isArchived END,
          custom_name = CASE
            WHEN sessions.session_id <> sessions.provider_session_id AND sessions.custom_name IS NOT NULL
              THEN sessions.custom_name
@@ -155,6 +159,7 @@ export const sessionsDb = {
       normalizedProjectPath,
       jsonlPath ?? null,
       createdAtValue,
+      updatedAtValue,
       updatedAtValue
     );
 
@@ -189,6 +194,55 @@ export const sessionsDb = {
     return sessionId;
   },
 
+  /**
+   * Inserts a session that already has its provider artifact on disk.
+   *
+   * Unlike `createAppSession` this writes `provider_session_id` and
+   * `jsonl_path` immediately, because a fork's transcript file exists before
+   * the row does — and the filesystem watcher would otherwise index it as an
+   * unrelated session under its own id.
+   */
+  createForkedSession(input: {
+    sessionId: string;
+    provider: string;
+    projectPath: string;
+    customName: string | null;
+    providerSessionId: string;
+    jsonlPath: string;
+    forkedFromSessionId: string;
+    model: string | null;
+    effort: string | null;
+  }): string {
+    const db = getConnection();
+    const normalizedProjectPath = normalizeProjectPathForProvider(input.provider, input.projectPath);
+
+    projectsDb.createProjectPath(normalizedProjectPath);
+
+    // The watcher may already have created a row for the new transcript. Its
+    // id is the provider-native one, which is what this row claims, so replace
+    // it rather than leaving two sidebar entries for one conversation.
+    db.transaction(() => {
+      db.prepare('DELETE FROM sessions WHERE session_id = ? AND session_id <> ?')
+        .run(input.providerSessionId, input.sessionId);
+      db.prepare(
+        `INSERT INTO sessions (session_id, provider, provider_session_id, custom_name, project_path, jsonl_path, model, effort, forked_from_session_id, isArchived, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`
+      ).run(
+        input.sessionId,
+        input.provider,
+        input.providerSessionId,
+        input.customName,
+        normalizedProjectPath,
+        input.jsonlPath,
+        input.model,
+        input.effort,
+        input.forkedFromSessionId,
+      );
+    })();
+
+    return input.sessionId;
+  },
+
   /**
    * Records the provider-native session id for one app-allocated session.
    *
@@ -235,6 +289,125 @@ export const sessionsDb = {
     merge();
   },
 
+  /**
+   * Moves one session onto a different provider session and transcript.
+   *
+   * Only editing a message on a provider that has to branch to rewind (Codex)
+   * does this — an ordinary run keeps the same provider session for its whole
+   * life. `assignProviderSessionId` cannot be used for it: that one keeps the
+   * existing `jsonl_path` on purpose, so a session repointed with it would
+   * claim the new thread while still reading the old transcript.
+   *
+   * The watcher may already have indexed the new transcript under its own id.
+   * That row is the same conversation this one is about to become, so it is
+   * replaced rather than left behind as a second sidebar entry.
+   */
+  repointSessionToProviderSession(
+    sessionId: string,
+    input: { providerSessionId: string; jsonlPath: string },
+  ): void {
+    const db = getConnection();
+
+    db.transaction(() => {
+      db.prepare('DELETE FROM sessions WHERE session_id = ? AND session_id <> ?')
+        .run(input.providerSessionId, sessionId);
+      db.prepare(
+        `UPDATE sessions SET
+           provider_session_id = ?,
+           jsonl_path = ?,
+           updated_at = CURRENT_TIMESTAMP
+         WHERE session_id = ?`
+      ).run(input.providerSessionId, input.jsonlPath, sessionId);
+    })();
+  },
+
+  /**
+   * Detaches a session from its provider session so the next run starts a new
+   * one.
+   *
+   * Used when an edit replaces the very first prompt: there is no conversation
+   * left to branch from, so the session starts over instead.
+   */
+  detachProviderSession(sessionId: string): void {
+    const db = getConnection();
+    db.prepare(
+      `UPDATE sessions SET
+         provider_session_id = NULL,
+         jsonl_path = NULL,
+         updated_at = CURRENT_TIMESTAMP
+       WHERE session_id = ?`
+    ).run(sessionId);
+  },
+
+  /**
+   * Records that a session has left a provider session behind for good.
+   *
+   * The transcript stays on disk, which is deliberate — the abandoned attempt
+   * is recoverable — but the indexer must not offer it back, and on a session
+   * discovered from disk (whose app id *is* the provider id) rediscovering it
+   * would repoint the row at the conversation the user edited away from.
+   */
+  markProviderSessionSuperseded(input: {
+    providerSessionId: string;
+    provider: string;
+    sessionId: string;
+    jsonlPath: string | null;
+  }): void {
+    const db = getConnection();
+    db.prepare(
+      `INSERT INTO superseded_provider_sessions (provider_session_id, provider, session_id, jsonl_path)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(provider_session_id, provider) DO UPDATE SET
+         session_id = excluded.session_id,
+         jsonl_path = excluded.jsonl_path,
+         created_at = CURRENT_TIMESTAMP`
+    ).run(input.providerSessionId, input.provider, input.sessionId, input.jsonlPath);
+  },
+
+  isProviderSessionSuperseded(providerSessionId: string, provider: string): boolean {
+    const db = getConnection();
+    const row = db
+      .prepare(
+        `SELECT 1 AS found FROM superseded_provider_sessions
+         WHERE provider_session_id = ? AND provider = ?
+         LIMIT 1`
+      )
+      .get(providerSessionId, provider) as { found: number } | undefined;
+
+    return Boolean(row);
+  },
+
+  /**
+   * Transcripts one session has left behind, for the caller that deletes a
+   * conversation from disk.
+   *
+   * A conversation edited more than once has lived in more than one file, and
+   * the session row only ever points at the newest.
+   */
+  getSupersededTranscriptPaths(sessionId: string): string[] {
+    const db = getConnection();
+    const rows = db
+      .prepare(
+        `SELECT jsonl_path FROM superseded_provider_sessions
+         WHERE session_id = ? AND jsonl_path IS NOT NULL`
+      )
+      .all(sessionId) as Array<{ jsonl_path: string }>;
+
+    return rows.map((row) => row.jsonl_path);
+  },
+
+  /**
+   * Forgets what a session left behind, once the session itself is gone.
+   *
+   * Without this the record outlives the row it was written for and keeps the
+   * indexer refusing a transcript that no longer belongs to anything — a
+   * conversation invisible to the app and impossible to delete through it.
+   */
+  clearSupersededProviderSessions(sessionId: string): void {
+    const db = getConnection();
+    db.prepare('DELETE FROM superseded_provider_sessions WHERE session_id = ?').run(sessionId);
+  },
+
   /**
    * Records the model one session runs with.
    *
@@ -521,4 +694,32 @@ export const sessionsDb = {
     const db = getConnection();
     return db.prepare('DELETE FROM sessions WHERE session_id = ?').run(sessionId).changes > 0;
   },
+
+  /** Used by the OpenCode synchronizer to remove indexed child sessions by their native id. */
+  deleteSessionByProviderSessionId(providerSessionId: string, provider: string): boolean {
+    const db = getConnection();
+    return db
+      .prepare('DELETE FROM sessions WHERE provider_session_id = ? AND provider = ?')
+      .run(providerSessionId, provider).changes > 0;
+  },
+
+  /**
+   * Lists every indexed session that claims a transcript file on disk.
+   *
+   * Only rows with a `jsonl_path` are returned, which deliberately excludes
+   * app-created sessions still waiting for their first provider write and
+   * OpenCode rows (whose transcripts all live inside one shared sqlite file).
+   * Used by the session synchronizer to find rows whose transcript has been
+   * deleted underneath the index.
+   */
+  getSessionsWithTranscriptPath(): Array<{ session_id: string; jsonl_path: string }> {
+    const db = getConnection();
+    return db
+      .prepare(
+        `SELECT session_id, jsonl_path
+         FROM sessions
+         WHERE jsonl_path IS NOT NULL AND jsonl_path <> ''`
+      )
+      .all() as Array<{ session_id: string; jsonl_path: string }>;
+  },
 };

package/server/modules/database/repositories/user-preferences.db.ts

@@ -0,0 +1,80 @@
+import { getConnection } from '@/modules/database/connection.js';
+
+type PreferenceRow = {
+  preference_key: string;
+  preference_value: string;
+};
+
+/**
+ * Decodes one stored preference, dropping any row whose JSON no longer parses
+ * rather than failing the whole read. A single corrupted value must not cost
+ * the user every other setting they have.
+ */
+function decodePreference(row: PreferenceRow): [string, unknown] | null {
+  try {
+    return [row.preference_key, JSON.parse(row.preference_value) as unknown];
+  } catch {
+    console.warn(`[UserPreferences] Dropping unreadable value for "${row.preference_key}"`);
+    return null;
+  }
+}
+
+export const userPreferencesDb = {
+  /**
+   * Returns every preference the user has ever set, as one object.
+   *
+   * The client fetches this once on start-up, so absent keys simply mean "the
+   * user never changed this" and the client applies its own default.
+   */
+  getPreferences(userId: number): Record<string, unknown> {
+    const db = getConnection();
+    const rows = db
+      .prepare(
+        `SELECT preference_key, preference_value
+         FROM user_preferences
+         WHERE user_id = ?`
+      )
+      .all(userId) as PreferenceRow[];
+
+    const preferences: Record<string, unknown> = {};
+    for (const row of rows) {
+      const decoded = decodePreference(row);
+      if (decoded) {
+        preferences[decoded[0]] = decoded[1];
+      }
+    }
+
+    return preferences;
+  },
+
+  /**
+   * Merge-patches preferences: keys present in `updates` are written, keys
+   * absent are left alone, and a key given as `undefined` is deleted.
+   *
+   * Runs in one transaction so a multi-key save from the settings dialog can
+   * never be observed half-applied.
+   */
+  savePreferences(userId: number, updates: Record<string, unknown>): void {
+    const db = getConnection();
+    const upsert = db.prepare(
+      `INSERT INTO user_preferences (user_id, preference_key, preference_value, updated_at)
+       VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(user_id, preference_key) DO UPDATE SET
+         preference_value = excluded.preference_value,
+         updated_at = CURRENT_TIMESTAMP`
+    );
+    const remove = db.prepare(
+      'DELETE FROM user_preferences WHERE user_id = ? AND preference_key = ?'
+    );
+
+    db.transaction(() => {
+      for (const [key, value] of Object.entries(updates)) {
+        if (value === undefined) {
+          remove.run(userId, key);
+          continue;
+        }
+        upsert.run(userId, key, JSON.stringify(value));
+      }
+    })();
+  },
+};

package/server/modules/database/schema.ts

@@ -96,6 +96,30 @@ CREATE TABLE IF NOT EXISTS projects (
 );
 `;
 
+export const SCHEDULED_MESSAGES_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS scheduled_messages (
+    id TEXT PRIMARY KEY,
+    user_id INTEGER NOT NULL,
+    session_id TEXT NOT NULL,
+    content TEXT NOT NULL,
+    -- Composer preferences (model, effort, permission mode, attachments) as
+    -- they were when the message was scheduled, so it runs the way the user
+    -- set it up rather than however the session is configured hours later.
+    options TEXT NOT NULL DEFAULT '{}',
+    -- UTC. The client sends an absolute instant so the schedule does not move
+    -- when the user changes time zone between scheduling and firing.
+    scheduled_for DATETIME NOT NULL,
+    -- pending | sent | failed | cancelled
+    status TEXT NOT NULL DEFAULT 'pending',
+    -- Why a failed one failed, shown next to it in the composer.
+    failure_reason TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+);
+`;
+
 export const SESSIONS_TABLE_SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS sessions (
     session_id TEXT NOT NULL,
@@ -114,6 +138,10 @@ CREATE TABLE IF NOT EXISTS sessions (
     -- restores its exact runtime configuration instead of provider defaults.
     model TEXT,
     effort TEXT,
+    -- The app session this one was branched from, NULL for sessions created
+    -- normally. Informational only: a fork is a fully independent provider
+    -- session, and deleting the source does not affect it.
+    forked_from_session_id TEXT,
     isArchived BOOLEAN DEFAULT 0,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
@@ -146,6 +174,11 @@ CREATE TABLE IF NOT EXISTS app_config (
  * controlled in each provider's `-models.provider.ts` adapter so they can be
  * updated without migrating application data. `model_id` is unique only within
  * a provider because different CLIs can accept the same identifier.
+ *
+ * `effort_values` (JSON array of level ids) and `effort_default` hold the
+ * reasoning-effort levels the user declared for the model; both stay NULL when
+ * none were declared. They sit after the timestamps so fresh installs match the
+ * column order that `runMigrations` produces on upgraded databases.
  */
 export const PROVIDER_MODELS_TABLE_SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS provider_models (
@@ -156,10 +189,74 @@ CREATE TABLE IF NOT EXISTS provider_models (
     sort_order INTEGER NOT NULL DEFAULT 0,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    effort_values TEXT DEFAULT NULL,
+    effort_default TEXT DEFAULT NULL,
     UNIQUE(provider, model_id)
 );
 `;
 
+/**
+ * Per-user application preferences that used to live in browser localStorage.
+ *
+ * One row per (user, key); `preference_value` is always a JSON document so a
+ * key can hold a scalar (`"dark"`), a flag (`false`) or a whole settings blob
+ * without the schema having to know which. Keeping them server-side is what
+ * makes a preference follow the user from one device to another.
+ */
+export const USER_PREFERENCES_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS user_preferences (
+    user_id INTEGER NOT NULL,
+    preference_key TEXT NOT NULL,
+    preference_value TEXT NOT NULL,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (user_id, preference_key),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+`;
+
+/**
+ * Unsent composer text and queued messages, per user and per chat scope.
+ *
+ * `draft_scope` is a session id, or `project:<projectId>` for a chat that has
+ * not been sent yet and therefore has no session. Storing this server-side is
+ * what lets a message typed on a laptop be finished on a phone.
+ */
+export const SESSION_DRAFTS_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS session_drafts (
+    user_id INTEGER NOT NULL,
+    draft_scope TEXT NOT NULL,
+    draft_text TEXT NOT NULL DEFAULT '',
+    queued_message TEXT,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (user_id, draft_scope),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+`;
+
+/**
+ * Provider sessions an app session has moved off, and must never move back to.
+ *
+ * Editing a message on a provider that cannot resume a transcript partway
+ * (Codex) is done by branching: the conversation is copied up to the edited
+ * turn and the app session follows the copy. The original transcript is left
+ * on disk untouched — nothing is deleted — but it is no longer the session's,
+ * and the indexer would otherwise rediscover it on its next full scan and hand
+ * the session back to the version the user edited away from.
+ */
+export const SUPERSEDED_PROVIDER_SESSIONS_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS superseded_provider_sessions (
+    provider_session_id TEXT NOT NULL,
+    provider TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    -- The transcript the session left behind. Recorded because the session row
+    -- stops pointing at it, and "delete this conversation from disk" has to
+    -- reach every file the conversation ever lived in.
+    jsonl_path TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (provider_session_id, provider)
+);
+`;
+
 export const INIT_SCHEMA_SQL = `
 -- Initialize authentication database
 PRAGMA foreign_keys = ON;
@@ -207,4 +304,10 @@ ${APP_CONFIG_TABLE_SCHEMA_SQL}
 ${PROVIDER_MODELS_TABLE_SCHEMA_SQL}
 CREATE INDEX IF NOT EXISTS idx_provider_models_provider_order
 ON provider_models(provider, sort_order, id);
+
+${USER_PREFERENCES_TABLE_SCHEMA_SQL}
+
+${SESSION_DRAFTS_TABLE_SCHEMA_SQL}
+
+${SUPERSEDED_PROVIDER_SESSIONS_TABLE_SCHEMA_SQL}
 `;

package/server/modules/database/tests/provider-models.db.integration.test.ts

@@ -4,6 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
+import Database from 'better-sqlite3';
+
 import {
   closeConnection,
   getConnection,
@@ -35,6 +37,8 @@ test('provider model repository stores custom rows only and maintains session re
       'sort_order',
       'created_at',
       'updated_at',
+      'effort_values',
+      'effort_default',
     ]);
     assert.deepEqual(providerModelsDb.listCustomProviderModels('codex'), []);
 
@@ -43,6 +47,7 @@ test('provider model repository stores custom rows only and maintains session re
       id: 'gateway/model-v1',
     });
     assert.equal(custom.modelId, 'gateway/model-v1');
+    assert.equal(custom.effort, null);
     assert.equal(
       providerModelsDb.findCustomProviderModelByModelId('codex', 'gateway/model-v1')?.recordId,
       custom.recordId,
@@ -123,3 +128,111 @@ test('migrations create the provider model index on an install that lacks it', a
     await rm(tempDirectory, { recursive: true, force: true });
   }
 });
+
+test('provider model repository persists declared effort levels', async () => {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'provider-model-effort-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await writeFile(databasePath, '');
+  await initializeDatabase();
+
+  try {
+    const custom = providerModelsDb.createCustomProviderModel('claude', {
+      model: 'My Custom Model',
+      id: 'my-custom-model',
+      effort: { values: ['low', 'high'], default: 'high' },
+    });
+    assert.deepEqual(custom.effort, { values: ['low', 'high'], default: 'high' });
+    assert.deepEqual(
+      providerModelsDb.listCustomProviderModels('claude')[0]?.effort,
+      { values: ['low', 'high'], default: 'high' },
+    );
+
+    // Omitting effort on update keeps the stored levels.
+    const renamed = providerModelsDb.updateCustomProviderModel('claude', custom.recordId, {
+      model: 'Renamed',
+      id: 'my-custom-model',
+    });
+    assert.deepEqual(renamed?.effort, { values: ['low', 'high'], default: 'high' });
+
+    const narrowed = providerModelsDb.updateCustomProviderModel('claude', custom.recordId, {
+      model: 'Renamed',
+      id: 'my-custom-model',
+      effort: { values: ['medium'] },
+    });
+    assert.deepEqual(narrowed?.effort, { values: ['medium'] });
+
+    const cleared = providerModelsDb.updateCustomProviderModel('claude', custom.recordId, {
+      model: 'Renamed',
+      id: 'my-custom-model',
+      effort: null,
+    });
+    assert.equal(cleared?.effort, null);
+    const row = getConnection()
+      .prepare('SELECT effort_values, effort_default FROM provider_models WHERE id = ?')
+      .get(custom.recordId);
+    assert.deepEqual(row, { effort_values: null, effort_default: null });
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('migrations add effort columns to an existing provider model table and keep old rows NULL', async () => {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'provider-model-effort-migration-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  // The table as it shipped before effort metadata existed, with one user row.
+  const legacyDb = new Database(databasePath);
+  legacyDb.exec(`
+    CREATE TABLE provider_models (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      provider TEXT NOT NULL CHECK (provider IN ('claude', 'cursor', 'codex', 'opencode')),
+      model_id TEXT NOT NULL,
+      model_name TEXT NOT NULL,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE(provider, model_id)
+    );
+    INSERT INTO provider_models (provider, model_id, model_name, sort_order)
+    VALUES ('codex', 'legacy-model', 'Legacy Model', 0);
+  `);
+  legacyDb.close();
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await initializeDatabase();
+
+  try {
+    const columnNames = (getConnection().prepare('PRAGMA table_info(provider_models)').all() as Array<{
+      name: string;
+    }>).map((column) => column.name);
+    assert.deepEqual(columnNames.slice(-2), ['effort_values', 'effort_default']);
+
+    const [legacy] = providerModelsDb.listCustomProviderModels('codex');
+    assert.equal(legacy?.modelId, 'legacy-model');
+    assert.equal(legacy?.effort, null);
+
+    // Running the migrations again is a no-op.
+    runMigrations(getConnection());
+    assert.equal(providerModelsDb.listCustomProviderModels('codex')[0]?.effort, null);
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});

package/server/modules/database/tests/sessions.db.integration.test.ts

@@ -72,6 +72,58 @@ test('createSession reactivates archived rows when the session becomes active ag
   });
 });
 
+test("createSession leaves an archived row archived when the transcript has not changed", async () => {
+  await withIsolatedDatabase(() => {
+    const createdAt = "2026-07-18T09:00:00.000Z";
+    const updatedAt = "2026-07-18T10:00:00.000Z";
+    const jsonlPath = "/transcripts/session-untouched.jsonl";
+
+    sessionsDb.createSession("session-untouched", "claude", "/workspace/demo-project", "A Name", createdAt, updatedAt, jsonlPath);
+    sessionsDb.updateSessionIsArchived("session-untouched", true);
+
+    // A full rescan re-indexes every transcript created since the last scan,
+    // changed or not, and hands over the timestamps the file still carries.
+    sessionsDb.createSession("session-untouched", "claude", "/workspace/demo-project", "A Name", createdAt, updatedAt, jsonlPath);
+
+    assert.equal(sessionsDb.getSessionById("session-untouched")?.isArchived, 1);
+    assert.equal(sessionsDb.getArchivedSessions().length, 1);
+    assert.equal(sessionsDb.getAllSessions().length, 0);
+
+    // Actually writing to the session again still brings it back.
+    sessionsDb.createSession("session-untouched", "claude", "/workspace/demo-project", "A Name", createdAt, "2026-07-18T11:00:00.000Z", jsonlPath);
+
+    assert.equal(sessionsDb.getSessionById("session-untouched")?.isArchived, 0);
+  });
+});
+
+test("the upsert path counts an omitted timestamp as activity", async () => {
+  await withIsolatedDatabase(() => {
+    // An app-created row carries no provider id, so indexing it takes the
+    // INSERT ... ON CONFLICT branch rather than the UPDATE above. Its
+    // updated_at is CURRENT_TIMESTAMP, which resolves to whole seconds, so a
+    // call in the same second is not *newer* -- the omitted timestamp itself
+    // has to be what reactivates the row.
+    sessionsDb.createAppSession("session-legacy", "claude", "/workspace/demo-project");
+    sessionsDb.updateSessionIsArchived("session-legacy", true);
+
+    sessionsDb.createSession("session-legacy", "claude", "/workspace/demo-project", "Indexed Name");
+
+    assert.equal(sessionsDb.getSessionById("session-legacy")?.isArchived, 0);
+  });
+});
+
+test("the upsert path leaves an archived row alone for a transcript older than it", async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession("session-stale", "claude", "/workspace/demo-project");
+    sessionsDb.updateSessionIsArchived("session-stale", true);
+
+    sessionsDb.createSession("session-stale", "claude", "/workspace/demo-project", "Indexed Name", "2026-07-18T09:00:00.000Z", "2026-07-18T10:00:00.000Z", "/transcripts/session-stale.jsonl");
+
+    assert.equal(sessionsDb.getSessionById("session-stale")?.isArchived, 1);
+  });
+});
+
+
 test('repository reads normalize SQLite UTC timestamps to ISO strings', async () => {
   await withIsolatedDatabase(() => {
     sessionsDb.createAppSession('session-timezone', 'claude', '/workspace/demo-project');